mm_eslint 1.4.5 → 1.4.7

package/lib/fix/method_fix.js

@@ -0,0 +1,82 @@
+/**
+ * 方法相关修复函数
+ * 负责处理方法定义、类方法等AST节点的修复逻辑
+ */
+class MethodFix {
+  /**
+   * 构造函数
+   * @param {object} config 配置对象
+   */
+  constructor(config) {
+    this.config = config;
+  }
+
+  /**
+   * 创建方法修复函数
+   * @param {object} context ESLint上下文
+   * @param {object} node AST节点
+   * @param {object} error 错误信息
+   * @returns {function} 修复函数
+   */
+  createMethodFixFunction(context, node, error) {
+    var old_name = error.name;
+    var new_name = error.fix_suggestion;
+    
+    if (!old_name || !new_name) {
+      return function(fixer) {
+        return [];
+      };
+    }
+
+    return function(fixer) {
+      // 方法定义特殊处理
+      if (node.type === 'MethodDefinition' && node.key && (node.key.type === 'Identifier' || node.key.type === 'PrivateIdentifier') && node.key.name === old_name) {
+        // 私有标识符需要保留 # 前缀
+        if (node.key.type === 'PrivateIdentifier') {
+          return fixer.replaceText(node.key, '#' + new_name);
+        }
+        return fixer.replaceText(node.key, new_name);
+      }
+      
+      // 类中的方法处理
+      if (node.type === 'ClassBody' && node.parent && node.parent.type === 'ClassDeclaration') {
+        for (var i = 0; i < node.body.length; i++) {
+          var method = node.body[i];
+          if (method.type === 'MethodDefinition' && method.key && method.key.type === 'Identifier' && method.key.name === old_name) {
+            return fixer.replaceText(method.key, new_name);
+          }
+        }
+      }
+      
+      // 通用查找作为备用方案
+      var identifier_node = this._findIdentifierNode(node, old_name);
+      if (identifier_node) {
+        return fixer.replaceText(identifier_node, new_name);
+      }
+      
+      return [];
+    }.bind(this);
+  }
+
+  /**
+   * 查找标识符节点
+   * @param {object} node AST节点
+   * @param {string} name 名称
+   * @returns {object|null} 标识符节点
+   */
+  _findIdentifierNode(node, name) {
+    // 如果是标识符节点且名称匹配
+    if (node.type === 'Identifier' && node.name === name) {
+      return node;
+    }
+    
+    // 如果是方法定义，检查方法名标识符
+    if (node.type === 'MethodDefinition' && node.key && node.key.type === 'Identifier' && node.key.name === name) {
+      return node.key;
+    }
+    
+    return null;
+  }
+}
+
+module.exports = { MethodFix };

package/lib/fix/param_fix.js

@@ -0,0 +1,63 @@
+/**
+ * 参数相关修复函数
+ * 负责处理函数参数等AST节点的修复逻辑
+ */
+class ParamFix {
+  /**
+   * 构造函数
+   * @param {object} config 配置对象
+   */
+  constructor(config) {
+    this.config = config;
+  }
+
+  /**
+   * 创建参数修复函数
+   * @param {object} context ESLint上下文
+   * @param {object} node AST节点
+   * @param {object} error 错误信息
+   * @returns {function} 修复函数
+   */
+  createParamFixFunction(context, node, error) {
+    var old_name = error.name;
+    var new_name = error.fix_suggestion;
+    
+    if (!old_name || !new_name) {
+      return function(fixer) {
+        return [];
+      };
+    }
+
+    return function(fixer) {
+      // 函数参数特殊处理：直接查找参数标识符
+      if (node.type === 'Identifier' && node.name === old_name) {
+        return fixer.replaceText(node, new_name);
+      }
+      
+      // 通用查找作为备用方案
+      var identifier_node = this._findIdentifierNode(node, old_name);
+      if (identifier_node) {
+        return fixer.replaceText(identifier_node, new_name);
+      }
+      
+      return [];
+    }.bind(this);
+  }
+
+  /**
+   * 查找标识符节点
+   * @param {object} node AST节点
+   * @param {string} name 名称
+   * @returns {object|null} 标识符节点
+   */
+  _findIdentifierNode(node, name) {
+    // 如果是标识符节点且名称匹配
+    if (node.type === 'Identifier' && node.name === name) {
+      return node;
+    }
+    
+    return null;
+  }
+}
+
+module.exports = { ParamFix };

package/lib/fix/property_fix.js

@@ -0,0 +1,93 @@
+/**
+ * 属性相关修复函数
+ * 负责处理对象属性、类属性定义等AST节点的修复逻辑
+ */
+class PropertyFix {
+  /**
+   * 构造函数
+   * @param {object} config 配置对象
+   */
+  constructor(config) {
+    this.config = config;
+  }
+
+  /**
+   * 创建属性修复函数
+   * @param {object} context ESLint上下文
+   * @param {object} node AST节点
+   * @param {object} error 错误信息
+   * @returns {function} 修复函数
+   */
+  createPropertyFixFunction(context, node, error) {
+    var old_name = error.name;
+    var new_name = error.fix_suggestion;
+    
+    if (!old_name || !new_name) {
+      return function(fixer) {
+        return [];
+      };
+    }
+
+    return function(fixer) {
+      // 对象属性特殊处理
+      if (node.type === 'Property' && node.key && node.key.type === 'Identifier' && node.key.name === old_name) {
+        return fixer.replaceText(node.key, new_name);
+      }
+      
+      // 类属性定义处理
+      if (node.type === 'PropertyDefinition' && node.key && (node.key.type === 'Identifier' || node.key.type === 'PrivateIdentifier') && node.key.name === old_name) {
+        // 私有标识符需要保留 # 前缀
+        if (node.key.type === 'PrivateIdentifier') {
+          return fixer.replaceText(node.key, '#' + new_name);
+        }
+        return fixer.replaceText(node.key, new_name);
+      }
+      
+      // 对象字面量属性处理
+      if (node.type === 'ObjectProperty' && node.key && node.key.type === 'Identifier' && node.key.name === old_name) {
+        return fixer.replaceText(node.key, new_name);
+      }
+      
+      // 赋值表达式中的成员表达式属性处理（如 Usersb.prototype._GetUserpe）
+      if (node.type === 'AssignmentExpression' && node.left && node.left.type === 'MemberExpression' && 
+          node.left.property && node.left.property.type === 'Identifier' && node.left.property.name === old_name) {
+        return fixer.replaceText(node.left.property, new_name);
+      }
+      
+      // 通用查找作为备用方案
+      var identifier_node = this._findIdentifierNode(node, old_name);
+      if (identifier_node) {
+        return fixer.replaceText(identifier_node, new_name);
+      }
+      
+      return [];
+    }.bind(this);
+  }
+
+  /**
+   * 查找标识符节点
+   * @param {object} node AST节点
+   * @param {string} name 名称
+   * @returns {object|null} 标识符节点
+   */
+  _findIdentifierNode(node, name) {
+    // 如果是标识符节点且名称匹配
+    if (node.type === 'Identifier' && node.name === name) {
+      return node;
+    }
+    
+    // 如果是属性，检查属性名标识符
+    if (node.type === 'Property' && node.key && node.key.type === 'Identifier' && node.key.name === name) {
+      return node.key;
+    }
+    
+    // 如果是类属性定义，检查属性名标识符
+    if (node.type === 'PropertyDefinition' && node.key && node.key.type === 'Identifier' && node.key.name === name) {
+      return node.key;
+    }
+    
+    return null;
+  }
+}
+
+module.exports = { PropertyFix };

package/lib/fix/variable_fix.js

@@ -0,0 +1,134 @@
+/**
+ * 变量相关修复函数
+ * 负责处理变量声明、赋值表达式等AST节点的修复逻辑
+ */
+class VariableFix {
+  /**
+   * 构造函数
+   * @param {object} config 配置对象
+   */
+  constructor(config) {
+    this.config = config;
+  }
+
+  /**
+   * 创建变量声明修复函数
+   * @param {object} context ESLint上下文
+   * @param {object} node AST节点
+   * @param {object} error 错误信息
+   * @returns {function} 修复函数
+   */
+  createVariableFixFunction(context, node, error) {
+    var old_name = error.name;
+    var new_name = error.fix_suggestion;
+    
+    if (!old_name || !new_name) {
+      return function(fixer) {
+        return [];
+      };
+    }
+
+    return function(fixer) {
+      var fixes = [];
+      
+      // 变量声明特殊处理：直接查找变量标识符
+      if (node.type === 'VariableDeclarator' && node.id && node.id.type === 'Identifier' && node.id.name === old_name) {
+        fixes.push(fixer.replaceText(node.id, new_name));
+      }
+      
+      // 赋值表达式中的变量处理
+      if (node.type === 'AssignmentExpression' && node.left && node.left.type === 'Identifier' && node.left.name === old_name) {
+        fixes.push(fixer.replaceText(node.left, new_name));
+      }
+      
+      // 通用查找作为备用方案
+      var identifier_node = this._findIdentifierNode(node, old_name);
+      if (identifier_node) {
+        fixes.push(fixer.replaceText(identifier_node, new_name));
+      }
+
+      return fixes;
+    }.bind(this);
+  }
+
+  /**
+   * 查找标识符节点
+   * @param {object} node AST节点
+   * @param {string} name 名称
+   * @returns {object|null} 标识符节点
+   */
+  _findIdentifierNode(node, name) {
+    // 如果是标识符节点且名称匹配
+    if (node.type === 'Identifier' && node.name === name) {
+      return node;
+    }
+    
+    // 如果是变量声明，检查声明标识符
+    if (node.type === 'VariableDeclaration' && node.declarations && node.declarations.length > 0) {
+      for (var i = 0; i < node.declarations.length; i++) {
+        var decl = node.declarations[i];
+        if (decl.id && decl.id.type === 'Identifier' && decl.id.name === name) {
+          return decl.id;
+        }
+      }
+    }
+    
+    // 如果是变量声明器，检查声明标识符
+    if (node.type === 'VariableDeclarator' && node.id && node.id.type === 'Identifier' && node.id.name === name) {
+      return node.id;
+    }
+    
+    // 如果是表达式中的标识符引用（如 Name + Age）
+    if (node.type === 'BinaryExpression' || node.type === 'CallExpression' || node.type === 'MemberExpression' || node.type === 'VariableDeclaration') {
+      // 递归查找子节点中的标识符
+      for (var key in node) {
+        if (node[key] && typeof node[key] === 'object') {
+          var result = this._findIdentifierNode(node[key], name);
+          if (result) {
+            return result;
+          }
+        }
+      }
+    }
+    
+    return null;
+  }
+
+  /**
+   * 查找所有标识符节点
+   * @param {object} node AST节点
+   * @param {string} name 名称
+   * @returns {array} 标识符节点数组
+   */
+  _findAllIdentifiers(node, name) {
+    var identifiers = [];
+    var visited = new Set();
+    
+    // 递归遍历AST树
+    function traverse(current_node) {
+      if (!current_node || typeof current_node !== 'object' || visited.has(current_node)) {
+        return;
+      }
+      
+      // 标记为已访问，避免无限递归
+      visited.add(current_node);
+      
+      // 如果是标识符节点且名称匹配
+      if (current_node.type === 'Identifier' && current_node.name === name) {
+        identifiers.push(current_node);
+      }
+      
+      // 递归遍历所有子节点
+      for (var key in current_node) {
+        if (current_node[key] && typeof current_node[key] === 'object') {
+          traverse(current_node[key]);
+        }
+      }
+    }
+    
+    traverse(node);
+    return identifiers;
+  }
+}
+
+module.exports = { VariableFix };

package/lib/fix.js

@@ -0,0 +1,160 @@
+/**
+ * 自动修复功能类
+ * 负责处理命名规范的自动修复逻辑
+ * 使用模块化修复函数，根据AST节点类型分发修复任务
+ */
+const { 
+  ClassFix, 
+  VariableFix, 
+  FunctionFix, 
+  PropertyFix, 
+  MethodFix, 
+  ParamFix, 
+  ExportFix 
+} = require('./fix/index.js');
+
+class Fix {
+  /**
+   * 构造函数
+   * @param {object} config 配置对象
+   */
+  constructor(config) {
+    this.config = config;
+    
+    // 初始化各个修复类实例
+    this.class_fix = new ClassFix(config);
+    this.variable_fix = new VariableFix(config);
+    this.function_fix = new FunctionFix(config);
+    this.property_fix = new PropertyFix(config);
+    this.method_fix = new MethodFix(config);
+    this.param_fix = new ParamFix(config);
+    this.export_fix = new ExportFix(config);
+  }
+
+  /**
+   * 根据节点类型创建修复函数
+   * @param {object} context ESLint上下文
+   * @param {object} node AST节点
+   * @param {object} error 错误信息
+   * @returns {function} 修复函数
+   */
+  createFixFunction(context, node, error) {
+    var node_type = node.type;
+    var original_type = error.original_type;
+    
+    // 根据节点类型或错误类型选择对应的修复函数
+    switch (node_type) {
+      case 'ClassDeclaration':
+      case 'ClassExpression':
+        return this.class_fix.createClassFixFunction(context, node, error);
+        
+      case 'VariableDeclaration':
+      case 'VariableDeclarator':
+      case 'AssignmentExpression':
+        return this.variable_fix.createVariableFixFunction(context, node, error);
+        
+      case 'FunctionDeclaration':
+      case 'FunctionExpression':
+      case 'ArrowFunctionExpression':
+      case 'CallExpression':
+        return this.function_fix.createFunctionFixFunction(context, node, error);
+        
+      case 'Property':
+      case 'PropertyDefinition':
+      case 'ObjectProperty':
+        return this.property_fix.createPropertyFixFunction(context, node, error);
+        
+      case 'MethodDefinition':
+      case 'ClassBody':
+        return this.method_fix.createMethodFixFunction(context, node, error);
+        
+      case 'Identifier':
+        // 如果是参数标识符
+        if (original_type && original_type.includes('param')) {
+          return this.param_fix.createParamFixFunction(context, node, error);
+        }
+        // 默认使用变量修复
+        return this.variable_fix.createVariableFixFunction(context, node, error);
+        
+      default:
+        // 根据错误类型选择修复函数
+        return this._createFixByErrorType(context, node, error, original_type);
+    }
+  }
+
+  /**
+   * 根据错误类型创建修复函数
+   * @param {object} context ESLint上下文
+   * @param {object} node AST节点
+   * @param {object} error 错误信息
+   * @param {string} original_type 原始类型
+   * @returns {function} 修复函数
+   */
+  _createFixByErrorType(context, node, error, original_type) {
+    if (!original_type) {
+      return function(fixer) {
+        return [];
+      };
+    }
+
+    switch (original_type) {
+      case 'class':
+      case 'super-class':
+        return this.class_fix.createClassFixFunction(context, node, error);
+        
+      case 'variable':
+      case 'object':
+      case 'constant':
+        return this.variable_fix.createVariableFixFunction(context, node, error);
+        
+      case 'function':
+        return this.function_fix.createFunctionFixFunction(context, node, error);
+        
+      case 'property':
+      case 'object-property':
+      case 'class-property':
+        return this.property_fix.createPropertyFixFunction(context, node, error);
+        
+      case 'method':
+      case 'class-method':
+        return this.method_fix.createMethodFixFunction(context, node, error);
+        
+      case 'param':
+      case 'function-param':
+      case 'arrow-function-param':
+        return this.param_fix.createParamFixFunction(context, node, error);
+        
+      default:
+        return this.variable_fix.createVariableFixFunction(context, node, error);
+    }
+  }
+
+  /**
+   * 修复导出语句中的引用
+   * @param {object} context ESLint上下文
+   * @param {string} old_name 旧名称
+   * @param {string} new_name 新名称
+   * @param {object} node AST节点
+   * @param {object} fixer 修复器
+   * @returns {array} 修复数组
+   */
+  fixExportReferences(context, old_name, new_name, node, fixer) {
+    return this.export_fix.fixExportReferences(context, old_name, new_name, node, fixer);
+  }
+
+  /**
+   * 创建修复函数（向后兼容）
+   * @param {Object} error 错误对象
+   * @param {string} suggestion 建议修复内容
+   * @returns 修复对象
+   */
+  createFunction(error, suggestion) {
+    // 保持向后兼容，但实际修复逻辑已转移到模块化修复函数中
+    return {
+      range: error.range,
+      text: suggestion
+    };
+  }
+}
+
+module.exports = { Fix };

package/{util.js → lib/util.js}

@@ -107,6 +107,14 @@ module.exports = {
    * @returns {object} 包含前缀和实际名称的对象
    */
   getRealName(name) {
+    // 如果name为undefined或null，返回默认值
+    if (name === undefined || name === null) {
+      return {
+        prefix: '',
+        real_name: ''
+      };
+    }
+    
     var real_name = name;
     var prefix = '';
     if (real_name.indexOf('_') === 0) {

package/{validator.js → lib/validator.js}

@@ -1,5 +1,5 @@
-const { Config } = require('./config');
-const { splitWords, getRealName } = require('./util');
+const { Config } = require('./config.js');
+const { splitWords, getRealName } = require('./util.js');
 
 /**
  * 命名规范验证器类
@@ -152,7 +152,7 @@ Validator.prototype._validateLength = function (name, min = 1, max = 32) {
  * @returns {string} 验证类型
  */
 Validator.prototype._getValidationType = function (original_type) {
-  return original_type.replace('property-', '').replace('static-', '').replace('prototype-', '').replace('private-', '').replace('internal-', '').replace('use-', '').replace('param-', '');
+  return this.config.getType(original_type);
 };
 
 /**

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "mm_eslint",
-  "version": "1.4.5",
-  "description": "ESLint plugin for naming conventions - PascalCase, camelCase, snake_case, and UPPER_SNAKE_CASE naming rules",
+  "version": "1.4.7",
+  "description": "ESLint plugin for personal naming conventions - supports PascalCase, camelCase, snake_case, and UPPER_SNAKE_CASE naming rules with intelligent recommendations",
   "main": "index.js",
   "keywords": [
     "eslint",
@@ -13,7 +13,12 @@
     "pascalcase",
     "camelcase",
     "snake-case",
-    "code-quality"
+    "code-quality",
+    "javascript",
+    "linting",
+    "code-style",
+    "best-practices",
+    "development-tools"
   ],
   "author": "qww",
   "license": "ISC",
@@ -32,20 +37,12 @@
     "eslint": ">=8.0.0"
   },
   "scripts": {
-    "test": "node test_module_integration.js",
+    "test": "node test_basic.js",
     "lint": "npx eslint . --config eslint.config.js"
   },
   "files": [
-    "config.js",
-    "corrector.js",
-    "detector.js",
-    "eslint.config.js",
-    "fix.js",
-    "handler.js",
     "index.js",
-    "tip.js",
-    "util.js",
-    "validator.js",
+    "lib/",
     "README.md",
     "README_EN.md",
     "LICENSE"