@sun-asterisk/sunlint 1.1.8 → 1.2.1

package/rules/common/C006_function_naming/analyzer.js

@@ -1,349 +0,0 @@
-const fs = require('fs');
-const path = require('path');
-const ts = require('typescript');
-
-class C006Analyzer {
-  constructor() {
-    this.ruleId = 'C006';
-    this.ruleName = 'Function Naming Convention';
-    this.description = 'Tên hàm phải là động từ/verb-noun pattern';
-  }
-
-  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.error(`Error analyzing file ${filePath}:`, error.message);
-      }
-    }
-
-    return violations;
-  }
-
-  async analyzeFile(filePath, content, language, config) {
-    switch (language) {
-      case 'typescript':
-      case 'javascript':
-        return this.analyzeTypeScript(filePath, content, config);
-      case 'dart':
-        return this.analyzeDart(filePath, content, config);
-      case 'kotlin':
-        return this.analyzeKotlin(filePath, content, config);
-      default:
-        return [];
-    }
-  }
-
-  async analyzeTypeScript(filePath, content, config) {
-    const violations = [];
-    const lines = content.split('\n');
-
-    // Parse TypeScript/JavaScript code
-    const sourceFile = ts.createSourceFile(
-      filePath,
-      content,
-      ts.ScriptTarget.Latest,
-      true
-    );
-
-    const visit = (node) => {
-      // Check function declarations (skip declare statements without body)
-      if (ts.isFunctionDeclaration(node) && node.name && node.body) {
-        const functionName = node.name.text;
-        const analysis = this.analyzeFunctionName(functionName);
-        
-        if (analysis.isViolation) {
-          const line = sourceFile.getLineAndCharacterOfPosition(node.getStart()).line + 1;
-          const column = sourceFile.getLineAndCharacterOfPosition(node.getStart()).character + 1;
-          const lineText = lines[line - 1]?.trim() || '';
-          
-          violations.push({
-            ruleId: this.ruleId,
-            file: filePath,
-            line,
-            column,
-            message: analysis.reason,
-            severity: analysis.severity || 'warning',
-            code: lineText,
-            type: analysis.type,
-            confidence: analysis.confidence || 0.8,
-            suggestion: analysis.suggestion
-          });
-        }
-      }
-
-      // Check method declarations
-      if (ts.isMethodDeclaration(node) && node.name) {
-        const methodName = node.name.text;
-        const analysis = this.analyzeFunctionName(methodName);
-        
-        if (analysis.isViolation) {
-          const line = sourceFile.getLineAndCharacterOfPosition(node.getStart()).line + 1;
-          const column = sourceFile.getLineAndCharacterOfPosition(node.getStart()).character + 1;
-          const lineText = lines[line - 1]?.trim() || '';
-          
-          violations.push({
-            ruleId: this.ruleId,
-            file: filePath,
-            line,
-            column,
-            message: analysis.reason,
-            severity: analysis.severity || 'warning',
-            code: lineText,
-            type: analysis.type,
-            confidence: analysis.confidence || 0.8,
-            suggestion: analysis.suggestion
-          });
-        }
-      }
-
-      // Check arrow functions assigned to variables
-      if (ts.isVariableDeclaration(node) && node.name && ts.isIdentifier(node.name) && 
-          node.initializer && ts.isArrowFunction(node.initializer)) {
-        const functionName = node.name.text;
-        const analysis = this.analyzeFunctionName(functionName);
-        
-        if (analysis.isViolation) {
-          const line = sourceFile.getLineAndCharacterOfPosition(node.getStart()).line + 1;
-          const column = sourceFile.getLineAndCharacterOfPosition(node.getStart()).character + 1;
-          const lineText = lines[line - 1]?.trim() || '';
-          
-          violations.push({
-            ruleId: this.ruleId,
-            file: filePath,
-            line,
-            column,
-            message: analysis.reason,
-            severity: analysis.severity || 'warning',
-            code: lineText,
-            type: analysis.type,
-            confidence: analysis.confidence || 0.8,
-            suggestion: analysis.suggestion
-          });
-        }
-      }
-      
-      ts.forEachChild(node, visit);
-    };
-
-    visit(sourceFile);
-    return violations;
-  }
-
-  async analyzeDart(filePath, content, config) {
-    const violations = [];
-    const lines = content.split('\n');
-
-    // Pattern-based analysis for Dart function declarations
-    const functionPattern = /^\s*(\w+\s+)?(\w+)\s*\([^)]*\)\s*\{?/;
-
-    lines.forEach((line, index) => {
-      const lineNumber = index + 1;
-      const match = line.match(functionPattern);
-      
-      if (match) {
-        const functionName = match[2];
-        
-        // Skip constructors, getters, setters, and built-in methods
-        if (this.isSpecialFunction(functionName)) {
-          return;
-        }
-        
-        const analysis = this.analyzeFunctionName(functionName);
-        
-        if (analysis.isViolation) {
-          violations.push({
-            ruleId: this.ruleId,
-            file: filePath,
-            line: lineNumber,
-            column: line.indexOf(functionName) + 1,
-            message: analysis.reason,
-            severity: analysis.severity || 'warning',
-            code: line.trim(),
-            type: analysis.type,
-            confidence: analysis.confidence || 0.7,
-            suggestion: analysis.suggestion
-          });
-        }
-      }
-    });
-
-    return violations;
-  }
-
-  async analyzeKotlin(filePath, content, config) {
-    const violations = [];
-    const lines = content.split('\n');
-
-    // Pattern-based analysis for Kotlin function declarations
-    const functionPattern = /^\s*(?:fun|private\s+fun|public\s+fun|internal\s+fun|override\s+fun)\s+(\w+)\s*\(/;
-
-    lines.forEach((line, index) => {
-      const lineNumber = index + 1;
-      const match = line.match(functionPattern);
-      
-      if (match) {
-        const functionName = match[1];
-        
-        // Skip constructors and built-in methods
-        if (this.isSpecialFunction(functionName)) {
-          return;
-        }
-        
-        const analysis = this.analyzeFunctionName(functionName);
-        
-        if (analysis.isViolation) {
-          violations.push({
-            ruleId: this.ruleId,
-            file: filePath,
-            line: lineNumber,
-            column: line.indexOf(functionName) + 1,
-            message: analysis.reason,
-            severity: analysis.severity || 'warning',
-            code: line.trim(),
-            type: analysis.type,
-            confidence: analysis.confidence || 0.7,
-            suggestion: analysis.suggestion
-          });
-        }
-      }
-    });
-
-    return violations;
-  }
-
-  analyzeFunctionName(functionName) {
-    // Skip special functions
-    if (this.isSpecialFunction(functionName)) {
-      return { isViolation: false };
-    }
-
-    // Common verbs for function names
-    const commonVerbs = [
-      'get', 'set', 'is', 'has', 'can', 'should', 'will', 'does',
-      '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',
-      'count', 'execute', 'perform', 'run', 'invoke', 'call',
-      'reset', 'initialize', 'setup', 'configure', 'prepare',
-      'refresh', 'restore', 'reload', 'retry', 'resume', 'redirect',
-      'select', 'toggle', 'switch', 'enable', 'disable', 'activate',
-      'expand', 'collapse', 'scroll', 'navigate', 'submit', 'cancel',
-      
-      // Based on user feedback - missing important verbs
-      'reopen', 'request', 'use', 'go',
-      
-      // Event handler prefixes  
-      'on',
-      
-      // Common React/JS patterns that should be allowed as verbs
-      'count', // can be both noun and verb - when standalone should be allowed
-      'request', // can be both noun and verb - when standalone should be allowed
-      'process' // can be both noun and verb - when standalone should be allowed
-    ];
-
-    // Check if function name starts with a verb
-    const startsWithVerb = commonVerbs.some(verb => {
-      const verbPattern = new RegExp(`^${verb}[A-Z]?`, 'i');
-      return verbPattern.test(functionName);
-    });
-
-    if (startsWithVerb) {
-      return { isViolation: false };
-    }
-
-    // Check for camelCase pattern that might be verb-noun
-    const camelCasePattern = /^[a-z][a-zA-Z0-9]*$/;
-    const pascalCasePattern = /^[A-Z][a-zA-Z0-9]*$/;
-    
-    // PascalCase functions (likely React components) - different rules
-    if (pascalCasePattern.test(functionName)) {
-      // For React components, we can be more lenient but still suggest verb patterns where appropriate
-      return {
-        isViolation: true,
-        reason: 'PascalCase function should be a React component or use verb-noun pattern',
-        severity: 'info',
-        type: 'react_component_naming',
-        confidence: 0.5,
-        suggestion: `If this is a React component, consider using descriptive names. If it's a function, use camelCase with verb-noun pattern.`
-      };
-    }
-    
-    if (!camelCasePattern.test(functionName)) {
-      return {
-        isViolation: true,
-        reason: 'Function name should follow camelCase and verb-noun pattern',
-        severity: 'warning',
-        type: 'naming_convention',
-        confidence: 0.9,
-        suggestion: 'Use camelCase with verb-noun pattern (e.g., getUserData, validateInput)'
-      };
-    }
-
-    // Check for noun-only patterns (likely violations)
-    const nounOnlyPatterns = [
-      /^[a-z]+$/,  // simple lowercase (e.g., 'user', 'data')
-      /^[a-z]+[A-Z][a-z]+$/,  // simple camelCase noun (e.g., 'userData', 'userInfo')
-    ];
-
-    const isNounOnly = nounOnlyPatterns.some(pattern => pattern.test(functionName));
-    
-    if (isNounOnly) {
-      return {
-        isViolation: true,
-        reason: 'Function name appears to be a noun - should start with a verb',
-        severity: 'warning',
-        type: 'missing_verb',
-        confidence: 0.8,
-        suggestion: `Consider renaming to use verb-noun pattern (e.g., get${functionName.charAt(0).toUpperCase() + functionName.slice(1)})`
-      };
-    }
-
-    // If it's a complex name without obvious verb, flag as potential violation
-    if (functionName.length > 3 && !functionName.match(/^[a-z]+[A-Z]/)) {
-      return {
-        isViolation: true,
-        reason: 'Function name should follow verb-noun pattern for clarity',
-        severity: 'info',
-        type: 'unclear_naming',
-        confidence: 0.6,
-        suggestion: 'Consider using verb-noun pattern for better readability'
-      };
-    }
-
-    return { isViolation: false };
-  }
-
-  isSpecialFunction(name) {
-    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'
-    ];
-
-    return specialFunctions.includes(name) || 
-           name.startsWith('_') || 
-           name.startsWith('$');
-           // Removed: || name.match(/^[A-Z]/); // Allow checking React components
-  }
-}
-
-module.exports = new C006Analyzer();

package/rules/common/C006_function_naming/config.json

@@ -1,86 +0,0 @@
-{
-  "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"
-    ]
-  }
-}