@sun-asterisk/sunlint 1.2.1 → 1.2.2

package/rules/common/C006_function_naming/analyzer.js

@@ -0,0 +1,504 @@
+const fs = require('fs');
+const path = require('path');
+const ts = require('typescript');
+
+/**
+ * SMART C006 ANALYZER - INTELLIGENT FUNCTION NAMING ANALYSIS
+ * 
+ * 🧠 5-TIER ANALYSIS APPROACH:
+ * 1. Context Analysis: File path, imports, class context
+ * 2. Semantic Analysis: Function body inspection for intent
+ * 3. Architectural Layer Detection: UI, Logic, Data, Utils
+ * 4. Natural Language Processing: Verb/noun classification
+ * 5. Confidence Scoring: Multi-factor violation assessment
+ */
+class SmartC006Analyzer {
+  constructor() {
+    this.ruleId = 'C006';
+    this.ruleName = 'Smart Function Naming Convention';
+    this.description = 'Intelligent verb-noun naming pattern detection with context awareness';
+    
+    // 🎯 CONFIDENCE THRESHOLDS
+    this.confidenceThresholds = {
+      HIGH: 0.8,    // Clear violations
+      MEDIUM: 0.6,  // Likely violations  
+      LOW: 0.4      // Potential violations
+    };
+    
+    // 🗂️ ARCHITECTURAL CONTEXT PATTERNS
+    this.architecturalLayers = {
+      UI: ['component', 'view', 'page', 'screen', 'modal', 'dialog'],
+      DATA: ['service', 'repository', 'dao', 'api', 'client', 'adapter'],
+      UTILS: ['util', 'helper', 'tool', 'lib', 'common'],
+      LOGIC: ['controller', 'handler', 'processor', 'manager', 'engine']
+    };
+    
+    // 🎭 SEMANTIC INTENT PATTERNS
+    this.semanticPatterns = {
+      // Return patterns indicate getters
+      GETTER: [/return\s+[^;]+/, /=>\s*[^{]/, /\?\s*[^:]+:/],
+      // Assignment patterns indicate setters
+      SETTER: [/=\s*[^=]/, /\.push\(/, /\.set\(/],
+      // Conditional patterns indicate checkers
+      CHECKER: [/if\s*\(/, /\?\s*/, /return\s+(true|false)/],
+      // Side effect patterns indicate actions
+      ACTION: [/console\./, /fetch\(/, /\.send\(/, /\.post\(/]
+    };
+  }
+
+  async analyze(files, language, config) {
+    const violations = [];
+    
+    if (config.verbose) {
+      console.log(`🔧 [DEBUG] Starting Smart C006 Analysis on ${files.length} files...`);
+    }
+
+    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) {
+        if (config.verbose) {
+          console.error(`⚠️ [DEBUG] Error analyzing file ${filePath}:`, error.message);
+        }
+      }
+    }
+
+    if (config.verbose) {
+      console.log(`🔧 [DEBUG] Smart C006 Analysis complete: ${violations.length} violations found`);
+    }
+    
+    return violations;
+  }
+
+  async analyzeFile(filePath, content, language, config) {
+    if (language !== 'typescript' && language !== 'javascript') {
+      return []; // Focus on TS/JS for now
+    }
+
+    const violations = [];
+    const lines = content.split('\n');
+    
+    // 🏗️ TIER 1: ARCHITECTURAL CONTEXT ANALYSIS
+    const architecturalContext = this.analyzeArchitecturalContext(filePath, content);
+    
+    // Parse TypeScript/JavaScript code
+    const sourceFile = ts.createSourceFile(
+      filePath,
+      content,
+      ts.ScriptTarget.Latest,
+      true
+    );
+
+    const visit = (node) => {
+      // Analyze function declarations
+      if (ts.isFunctionDeclaration(node) && node.name && node.body) {
+        const analysis = this.smartAnalyzeFunctionName(
+          node.name.text,
+          node,
+          sourceFile,
+          architecturalContext,
+          content
+        );
+        
+        if (analysis.isViolation && analysis.confidence >= this.confidenceThresholds.LOW) {
+          const namePosition = sourceFile.getLineAndCharacterOfPosition(node.name.getStart());
+          const line = namePosition.line + 1;
+          const column = namePosition.character + 1;
+          const lineText = lines[line - 1]?.trim() || '';
+          
+          violations.push({
+            ruleId: this.ruleId,
+            file: filePath,
+            line,
+            column,
+            message: analysis.reason,
+            severity: this.getSeverityFromConfidence(analysis.confidence),
+            code: lineText,
+            type: analysis.type,
+            confidence: analysis.confidence,
+            suggestion: analysis.suggestion,
+            context: analysis.context
+          });
+        }
+      }
+
+      // Analyze method declarations
+      if (ts.isMethodDeclaration(node) && node.name) {
+        const analysis = this.smartAnalyzeFunctionName(
+          node.name.text,
+          node,
+          sourceFile,
+          architecturalContext,
+          content
+        );
+        
+        if (analysis.isViolation && analysis.confidence >= this.confidenceThresholds.LOW) {
+          const namePosition = sourceFile.getLineAndCharacterOfPosition(node.name.getStart());
+          const line = namePosition.line + 1;
+          const column = namePosition.character + 1;
+          const lineText = lines[line - 1]?.trim() || '';
+          
+          violations.push({
+            ruleId: this.ruleId,
+            file: filePath,
+            line,
+            column,
+            message: analysis.reason,
+            severity: this.getSeverityFromConfidence(analysis.confidence),
+            code: lineText,
+            type: analysis.type,
+            confidence: analysis.confidence,
+            suggestion: analysis.suggestion,
+            context: analysis.context
+          });
+        }
+      }
+
+      // Analyze arrow functions assigned to variables
+      if (ts.isVariableDeclaration(node) && node.name && ts.isIdentifier(node.name) && 
+          node.initializer && ts.isArrowFunction(node.initializer)) {
+        const analysis = this.smartAnalyzeFunctionName(
+          node.name.text,
+          node.initializer,
+          sourceFile,
+          architecturalContext,
+          content
+        );
+        
+        if (analysis.isViolation && analysis.confidence >= this.confidenceThresholds.LOW) {
+          const namePosition = sourceFile.getLineAndCharacterOfPosition(node.name.getStart());
+          const line = namePosition.line + 1;
+          const column = namePosition.character + 1;
+          const lineText = lines[line - 1]?.trim() || '';
+          
+          violations.push({
+            ruleId: this.ruleId,
+            file: filePath,
+            line,
+            column,
+            message: analysis.reason,
+            severity: this.getSeverityFromConfidence(analysis.confidence),
+            code: lineText,
+            type: analysis.type,
+            confidence: analysis.confidence,
+            suggestion: analysis.suggestion,
+            context: analysis.context
+          });
+        }
+      }
+      
+      ts.forEachChild(node, visit);
+    };
+
+    visit(sourceFile);
+    return violations;
+  }
+
+  /**
+   * 🏗️ TIER 1: ARCHITECTURAL CONTEXT ANALYSIS
+   * Determines what type of file/module this is
+   */
+  analyzeArchitecturalContext(filePath, content) {
+    const fileName = path.basename(filePath, path.extname(filePath)).toLowerCase();
+    const fileDir = path.dirname(filePath).toLowerCase();
+    
+    // Detect architectural layer
+    let layer = 'UNKNOWN';
+    for (const [layerName, patterns] of Object.entries(this.architecturalLayers)) {
+      if (patterns.some(pattern => fileName.includes(pattern) || fileDir.includes(pattern))) {
+        layer = layerName;
+        break;
+      }
+    }
+    
+    // Analyze imports for additional context
+    const imports = this.extractImports(content);
+    const isReactComponent = imports.some(imp => imp.includes('react')) || content.includes('JSX.Element');
+    const isTestFile = fileName.includes('test') || fileName.includes('spec');
+    
+    return {
+      layer,
+      isReactComponent,
+      isTestFile,
+      fileName,
+      imports
+    };
+  }
+
+  /**
+   * 🧠 TIER 2: SEMANTIC ANALYSIS
+   * Analyzes function body to understand intent
+   */
+  analyzeSemanticIntent(functionNode, sourceFile, content) {
+    if (!functionNode.body) return 'UNKNOWN';
+    
+    const functionText = content.substring(
+      functionNode.body.getStart(),
+      functionNode.body.getEnd()
+    );
+    
+    // Check for different semantic patterns
+    for (const [intent, patterns] of Object.entries(this.semanticPatterns)) {
+      if (patterns.some(pattern => pattern.test(functionText))) {
+        return intent;
+      }
+    }
+    
+    return 'UNKNOWN';
+  }
+
+  /**
+   * 🎯 TIER 3: INTELLIGENT VERB DETECTION
+   * Uses multiple strategies to detect verbs
+   */
+  isVerbLikeName(functionName) {
+    // Strategy 1: Known verb prefixes (expanded beyond static list)
+    const verbPrefixes = [
+      'get', 'set', 'is', 'has', 'can', 'should', 'will', 'does',
+      'create', 'build', 'make', 'generate', 'construct', 'produce',
+      'update', 'modify', 'change', 'edit', 'alter', 'transform',
+      'delete', 'remove', 'destroy', 'clean', 'clear', 'reset',
+      'load', 'save', 'fetch', 'retrieve', 'find', 'search', 'query',
+      'validate', 'verify', 'check', 'confirm', 'ensure', 'test',
+      'calculate', 'compute', 'process', 'handle', 'manage', 'execute',
+      'send', 'receive', 'transmit', 'broadcast', 'emit', 'publish',
+      'parse', 'format', 'convert', 'map', 'filter', 'sort', 'group',
+      'connect', 'disconnect', 'open', 'close', 'start', 'stop', 'run',
+      'show', 'hide', 'display', 'render', 'draw', 'paint', 'animate',
+      'add', 'append', 'insert', 'push', 'pop', 'shift', 'splice',
+      'count', 'measure', 'monitor', 'watch', 'track', 'observe',
+      'refresh', 'restore', 'reload', 'retry', 'resume', 'redirect',
+      'select', 'toggle', 'switch', 'enable', 'disable', 'activate',
+      'expand', 'collapse', 'scroll', 'navigate', 'submit', 'cancel',
+      'on', 'handle', 'trigger', 'fire', 'dispatch', 'invoke', 'call'
+    ];
+    
+    // Strategy 2: Check if starts with known verb
+    const startsWithVerb = verbPrefixes.some(verb => {
+      const verbPattern = new RegExp(`^${verb}[A-Z]?`, 'i');
+      return verbPattern.test(functionName);
+    });
+    
+    if (startsWithVerb) return true;
+    
+    // Strategy 3: Common verb suffixes that indicate actions
+    const actionSuffixes = ['ize', 'ise', 'fy', 'ate', 'en'];
+    if (actionSuffixes.some(suffix => functionName.endsWith(suffix))) {
+      return true;
+    }
+    
+    // Strategy 4: English verb patterns (basic NLP)
+    const verbPatterns = [
+      /^(re|un|pre|de|dis)[A-Z]/, // prefixed verbs: revalidate, unload, preprocess
+      /^[a-z]+ly[A-Z]/, // adverb-verb patterns: quicklyProcess
+    ];
+    
+    return verbPatterns.some(pattern => pattern.test(functionName));
+  }
+
+  /**
+   * 🎭 TIER 4: CONTEXT-AWARE NAMING RULES
+   * Different rules for different contexts
+   */
+  getContextSpecificRules(architecturalContext, semanticIntent) {
+    const rules = {
+      allowedPatterns: [],
+      requiredPatterns: [],
+      suggestions: []
+    };
+    
+    // React components have different naming conventions
+    if (architecturalContext.isReactComponent) {
+      rules.allowedPatterns.push(/^[A-Z][a-zA-Z]*$/); // PascalCase components
+      rules.allowedPatterns.push(/^use[A-Z][a-zA-Z]*$/); // React hooks
+      rules.allowedPatterns.push(/^handle[A-Z][a-zA-Z]*$/); // Event handlers
+    }
+    
+    // Test files have different patterns
+    if (architecturalContext.isTestFile) {
+      rules.allowedPatterns.push(/^(test|it|describe|should|expect)[A-Z]?/);
+    }
+    
+    // Data layer functions often have CRUD patterns
+    if (architecturalContext.layer === 'DATA') {
+      rules.suggestions.push('Consider CRUD verbs: create, read, update, delete');
+    }
+    
+    // UI layer functions often have interaction verbs
+    if (architecturalContext.layer === 'UI') {
+      rules.suggestions.push('Consider UI verbs: show, hide, toggle, render, display');
+    }
+    
+    return rules;
+  }
+
+  /**
+   * 🎯 TIER 5: COMPREHENSIVE SMART ANALYSIS
+   * Combines all tiers for intelligent assessment
+   */
+  smartAnalyzeFunctionName(functionName, functionNode, sourceFile, architecturalContext, content) {
+    // Skip special functions
+    if (this.isSpecialFunction(functionName, architecturalContext)) {
+      return { isViolation: false };
+    }
+    
+    // Get semantic intent
+    const semanticIntent = this.analyzeSemanticIntent(functionNode, sourceFile, content);
+    
+    // Get context-specific rules
+    const contextRules = this.getContextSpecificRules(architecturalContext, semanticIntent);
+    
+    // Check if allowed by context-specific patterns
+    if (contextRules.allowedPatterns.some(pattern => pattern.test(functionName))) {
+      return { isViolation: false };
+    }
+    
+    // Check if name follows verb-noun pattern
+    const isVerbLike = this.isVerbLikeName(functionName);
+    
+    if (isVerbLike) {
+      return { isViolation: false };
+    }
+    
+    // 🧮 CONFIDENCE CALCULATION
+    let confidence = 0.5; // Base confidence
+    
+    // Boost confidence for clear noun-only patterns
+    if (/^[a-z]+$/.test(functionName)) {
+      confidence += 0.3; // Simple lowercase nouns: user, data
+    }
+    
+    if (/^[a-z]+[A-Z][a-z]+$/.test(functionName)) {
+      confidence += 0.2; // Simple camelCase nouns: userData, userInfo
+    }
+    
+    // Reduce confidence for complex names (might have hidden verbs)
+    if (functionName.length > 15) {
+      confidence -= 0.1;
+    }
+    
+    // Reduce confidence for utils/helpers (more flexible naming)
+    if (architecturalContext.layer === 'UTILS') {
+      confidence -= 0.2;
+    }
+    
+    // Reduce confidence for test files
+    if (architecturalContext.isTestFile) {
+      confidence -= 0.3;
+    }
+    
+    // Cap confidence
+    confidence = Math.min(Math.max(confidence, 0.1), 1.0);
+    
+    // 💬 INTELLIGENT MESSAGING
+    const context = {
+      layer: architecturalContext.layer,
+      intent: semanticIntent,
+      isReactComponent: architecturalContext.isReactComponent,
+      isTestFile: architecturalContext.isTestFile
+    };
+    
+    let reason = `Function '${functionName}' should follow verb-noun naming pattern`;
+    let suggestion = this.generateSmartSuggestion(functionName, semanticIntent, architecturalContext);
+    
+    if (architecturalContext.layer !== 'UNKNOWN') {
+      reason += ` (${architecturalContext.layer} layer)`;
+    }
+    
+    return {
+      isViolation: true,
+      reason,
+      type: 'smart_naming_violation',
+      confidence,
+      suggestion,
+      context
+    };
+  }
+
+  /**
+   * 💡 SMART SUGGESTION GENERATOR
+   */
+  generateSmartSuggestion(functionName, semanticIntent, architecturalContext) {
+    const baseNoun = functionName.charAt(0).toUpperCase() + functionName.slice(1);
+    
+    switch (semanticIntent) {
+      case 'GETTER':
+        return `get${baseNoun}()`;
+      case 'SETTER':
+        return `set${baseNoun}()`;
+      case 'CHECKER':
+        return `is${baseNoun}() or has${baseNoun}()`;
+      case 'ACTION':
+        return `process${baseNoun}() or handle${baseNoun}()`;
+      default:
+        if (architecturalContext.layer === 'DATA') {
+          return `fetch${baseNoun}() or create${baseNoun}()`;
+        }
+        if (architecturalContext.layer === 'UI') {
+          return `render${baseNoun}() or show${baseNoun}()`;
+        }
+        return `get${baseNoun}() or process${baseNoun}()`;
+    }
+  }
+
+  /**
+   * 🛡️ ENHANCED SPECIAL FUNCTION DETECTION
+   */
+  isSpecialFunction(name, architecturalContext) {
+    const specialFunctions = [
+      'constructor', 'toString', 'valueOf', 'toJSON',
+      'main', 'init', 'setup', 'teardown', 'build',
+      'onCreate', 'onDestroy', 'onStart', 'onStop',
+      'onPause', 'onResume', 'onSaveInstanceState',
+      'equals', 'hashCode', 'compareTo', 'clone',
+      'finalize', 'notify', 'notifyAll', 'wait'
+    ];
+
+    // Basic special function check
+    if (specialFunctions.includes(name) || name.startsWith('_') || name.startsWith('$')) {
+      return true;
+    }
+    
+    // React component names (PascalCase)
+    if (architecturalContext.isReactComponent && /^[A-Z][a-zA-Z]*$/.test(name)) {
+      return true;
+    }
+    
+    // React hooks
+    if (name.startsWith('use') && /^use[A-Z]/.test(name)) {
+      return true;
+    }
+    
+    // Test function names
+    if (architecturalContext.isTestFile && /^(test|it|describe|should|expect)/.test(name)) {
+      return true;
+    }
+    
+    return false;
+  }
+
+  /**
+   * 🎯 UTILITY METHODS
+   */
+  extractImports(content) {
+    const importRegex = /import\s+.*?\s+from\s+['"]([^'"]+)['"]/g;
+    const imports = [];
+    let match;
+    
+    while ((match = importRegex.exec(content)) !== null) {
+      imports.push(match[1]);
+    }
+    
+    return imports;
+  }
+
+  getSeverityFromConfidence(confidence) {
+    if (confidence >= this.confidenceThresholds.HIGH) return 'warning';
+    if (confidence >= this.confidenceThresholds.MEDIUM) return 'info';
+    return 'hint';
+  }
+}
+
+module.exports = new SmartC006Analyzer();

package/rules/common/C006_function_naming/config.json

@@ -0,0 +1,86 @@
+{
+  "ruleId": "C006",
+  "name": "Function Naming Convention",
+  "description": "Tên hàm phải là động từ/verb-noun pattern",
+  "category": "naming",
+  "severity": "warning",
+  "languages": ["typescript", "dart", "kotlin"],
+  "version": "1.0.0",
+  "status": "activated",
+  "tags": ["naming", "convention", "readability"],
+  "config": {
+    "commonVerbs": [
+      "get", "set", "is", "has", "can", "should", "will",
+      "create", "build", "make", "generate", "construct",
+      "update", "modify", "change", "edit", "alter",
+      "delete", "remove", "destroy", "clean", "clear",
+      "load", "save", "fetch", "retrieve", "find", "search",
+      "validate", "verify", "check", "confirm", "ensure",
+      "calculate", "compute", "process", "handle", "manage",
+      "send", "receive", "transmit", "broadcast", "emit",
+      "parse", "format", "transform", "convert", "map",
+      "filter", "sort", "group", "merge", "split",
+      "connect", "disconnect", "open", "close", "start", "stop",
+      "show", "hide", "display", "render", "draw", "paint",
+      "add", "append", "insert", "push", "pop", "shift",
+      "test", "debug", "log", "trace", "monitor", "watch"
+    ],
+    "specialFunctions": [
+      "constructor", "toString", "valueOf", "toJSON",
+      "main", "init", "setup", "teardown", "build",
+      "onCreate", "onDestroy", "onStart", "onStop",
+      "onPause", "onResume", "onSaveInstanceState",
+      "equals", "hashCode", "compareTo", "clone",
+      "finalize", "notify", "notifyAll", "wait"
+    ],
+    "patterns": {
+      "camelCase": "^[a-z][a-zA-Z0-9]*$",
+      "verbNoun": "^(get|set|is|has|can|create|update|delete|load|save|find|validate|process|handle|calculate|send|receive|parse|format|transform|filter|sort|connect|show|hide|add|remove)[A-Z][a-zA-Z0-9]*$"
+    }
+  },
+  "examples": {
+    "violations": [
+      {
+        "language": "typescript",
+        "code": "function userData() { return user.data; }",
+        "reason": "Function name is a noun - should start with a verb like 'getUserData'"
+      },
+      {
+        "language": "typescript",
+        "code": "function calculation() { return x + y; }",
+        "reason": "Should use verb-noun pattern like 'calculateSum' or 'performCalculation'"
+      },
+      {
+        "language": "dart",
+        "code": "String userInfo() { return 'info'; }",
+        "reason": "Function name should start with verb like 'getUserInfo'"
+      }
+    ],
+    "valid": [
+      {
+        "language": "typescript",
+        "code": "function getUserData() { return user.data; }",
+        "reason": "Follows verb-noun pattern"
+      },
+      {
+        "language": "typescript",
+        "code": "function isValid() { return true; }",
+        "reason": "Starts with verb 'is'"
+      },
+      {
+        "language": "dart",
+        "code": "bool hasPermission() { return true; }",
+        "reason": "Starts with verb 'has'"
+      }
+    ]
+  },
+  "fixes": {
+    "autoFixable": false,
+    "suggestions": [
+      "Start function names with verbs (get, set, is, has, create, update, etc.)",
+      "Use verb-noun pattern for clarity (e.g., getUserData, validateInput)",
+      "Avoid noun-only function names",
+      "Use camelCase convention"
+    ]
+  }
+}