mm_eslint 1.4.4 → 1.4.5

package/eslint.config.js

@@ -3,12 +3,15 @@ const mmEslint = require('./index.js');
 module.exports = [
   {
     files: ['**/*.js'],
+    ignores: ['node_modules/**', 'eslint.config.js'],
     languageOptions: {
-      ecmaVersion: 2022, // 支持类字段等ES2022特性
+      ecmaVersion: 'latest', // 支持类字段等ES2022特性
       sourceType: 'module'
     },
     plugins: {
-      'mm_eslint': mmEslint
+      mm_eslint: {
+        rules: mmEslint
+      }
     },
     rules: {
       'mm_eslint/class-name': 'error', // 类名命名规则

package/fix.js

@@ -0,0 +1,441 @@
+/**
+ * 自动修复功能类
+ * 负责处理命名规范的自动修复逻辑
+ */
+class Fix {
+  /**
+   * 构造函数
+   * @param {object} config 配置对象
+   */
+  constructor(config) {
+    this.config = config;
+  }
+
+  /**
+   * 创建类声明修复函数
+   * @param {object} context ESLint上下文
+   * @param {object} node AST节点
+   * @param {object} error 错误信息
+   * @returns {function} 修复函数
+   */
+  createClassFixFunction(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 === 'ClassDeclaration' && node.id && node.id.type === 'Identifier' && node.id.name === old_name) {
+        return fixer.replaceText(node.id, new_name);
+      }
+      
+      // 类表达式特殊处理
+      if (node.type === 'ClassExpression' && node.id && node.id.type === 'Identifier' && node.id.name === old_name) {
+        return fixer.replaceText(node.id, new_name);
+      }
+      
+      // 继承的父类名处理
+      if (node.type === 'ClassDeclaration' && node.superClass && node.superClass.type === 'Identifier' && node.superClass.name === old_name) {
+        return fixer.replaceText(node.superClass, 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} 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) {
+      // 变量声明特殊处理：直接查找变量标识符
+      if (node.type === 'VariableDeclarator' && node.id && node.id.type === 'Identifier' && node.id.name === old_name) {
+        return fixer.replaceText(node.id, new_name);
+      }
+      
+      // 赋值表达式中的变量处理
+      if (node.type === 'AssignmentExpression' && node.left && node.left.type === 'Identifier' && node.left.name === old_name) {
+        return fixer.replaceText(node.left, 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} 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} 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} context ESLint上下文
+   * @param {object} node AST节点
+   * @param {object} error 错误信息
+   * @returns {function} 修复函数
+   */
+  createFunctionFixFunction(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 === 'FunctionDeclaration' && node.id && node.id.type === 'Identifier' && node.id.name === old_name) {
+        return fixer.replaceText(node.id, new_name);
+      }
+      
+      // 函数表达式特殊处理
+      if (node.type === 'FunctionExpression' && node.id && node.id.type === 'Identifier' && node.id.name === old_name) {
+        return fixer.replaceText(node.id, new_name);
+      }
+      
+      // 箭头函数处理（通过父节点查找变量名）
+      if (node.type === 'ArrowFunctionExpression' && node.parent && node.parent.type === 'VariableDeclarator' && 
+          node.parent.id && node.parent.id.type === 'Identifier' && node.parent.id.name === old_name) {
+        return fixer.replaceText(node.parent.id, new_name);
+      }
+      
+      // 函数调用处理
+      if (node.type === 'CallExpression' && node.callee && node.callee.type === 'Identifier' && node.callee.name === old_name) {
+        return fixer.replaceText(node.callee, 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} 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;
+    }
+    
+    // 如果是变量声明，检查声明标识符
+    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;
+    }
+    
+    // 如果是函数声明，检查函数名标识符
+    if ((node.type === 'FunctionDeclaration' || node.type === 'FunctionExpression') && 
+        node.id && node.id.type === 'Identifier' && node.id.name === name) {
+      return node.id;
+    }
+    
+    // 如果是类声明，检查类名标识符
+    if (node.type === 'ClassDeclaration' && node.id && node.id.type === 'Identifier' && node.id.name === name) {
+      return node.id;
+    }
+    
+    // 如果是属性，检查属性名标识符
+    if (node.type === 'Property' && node.key && node.key.type === 'Identifier' && node.key.name === name) {
+      return node.key;
+    }
+    
+    // 如果是方法定义，检查方法名标识符
+    if (node.type === 'MethodDefinition' && node.key && node.key.type === 'Identifier' && node.key.name === name) {
+      return node.key;
+    }
+    
+    return null;
+  }
+
+  /**
+   * 修复导出语句中的引用
+   * @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) {
+    var fixes = [];
+    
+    // 获取当前文件的完整AST
+    var source_code = context.getSourceCode();
+    var ast = source_code.ast;
+    
+    // 遍历AST查找导出语句
+    this._traverseAST(ast, function(child_node) {
+      // 处理 module.exports = { ... } 形式的导出
+      if (child_node.type === 'AssignmentExpression' &&
+          child_node.left &&
+          child_node.left.type === 'MemberExpression' &&
+          child_node.left.object &&
+          child_node.left.object.type === 'Identifier' &&
+          child_node.left.object.name === 'module' &&
+          child_node.left.property &&
+          child_node.left.property.type === 'Identifier' &&
+          child_node.left.property.name === 'exports' &&
+          child_node.right &&
+          child_node.right.type === 'ObjectExpression') {
+        
+        // 检查对象字面量中的属性
+        for (var i = 0; i < child_node.right.properties.length; i++) {
+          var property = child_node.right.properties[i];
+          
+          // 处理简写属性（如 { AdminManager }）
+          if (property.shorthand && property.key && property.key.type === 'Identifier' && property.key.name === old_name) {
+            fixes.push(fixer.replaceText(property.key, new_name));
+          }
+          
+          // 处理普通属性（如 { AdminManager: AdminManager }）
+          if (!property.shorthand && property.key && property.key.type === 'Identifier' && property.key.name === old_name) {
+            fixes.push(fixer.replaceText(property.key, new_name));
+          }
+        }
+      }
+      
+      // 处理 exports.XXX = ... 形式的导出
+      if (child_node.type === 'AssignmentExpression' &&
+          child_node.left &&
+          child_node.left.type === 'MemberExpression' &&
+          child_node.left.object &&
+          child_node.left.object.type === 'Identifier' &&
+          child_node.left.object.name === 'exports' &&
+          child_node.left.property &&
+          child_node.left.property.type === 'Identifier' &&
+          child_node.left.property.name === old_name) {
+        
+        fixes.push(fixer.replaceText(child_node.left.property, new_name));
+      }
+      
+      // 处理 module.exports.XXX = ... 形式的导出
+      if (child_node.type === 'AssignmentExpression' &&
+          child_node.left &&
+          child_node.left.type === 'MemberExpression' &&
+          child_node.left.object &&
+          child_node.left.object.type === 'MemberExpression' &&
+          child_node.left.object.object &&
+          child_node.left.object.object.type === 'Identifier' &&
+          child_node.left.object.object.name === 'module' &&
+          child_node.left.object.property &&
+          child_node.left.object.property.type === 'Identifier' &&
+          child_node.left.object.property.name === 'exports' &&
+          child_node.left.property &&
+          child_node.left.property.type === 'Identifier' &&
+          child_node.left.property.name === old_name) {
+        
+        fixes.push(fixer.replaceText(child_node.left.property, new_name));
+      }
+    });
+    
+    return fixes;
+  }
+
+  /**
+   * 遍历AST节点
+   * @param {object} node AST节点
+   * @param {function} callback 回调函数
+   */
+  _traverseAST(node, callback) {
+    if (!node || typeof node !== 'object') {
+      return;
+    }
+    
+    // 调用回调函数处理当前节点
+    callback(node);
+    
+    // 递归遍历子节点
+    for (var k in node) {
+      if (node.hasOwnProperty(k)) {
+        var child = node[k];
+        if (Array.isArray(child)) {
+          for (var i = 0; i < child.length; i++) {
+            this._traverseAST(child[i], callback);
+          }
+        } else if (typeof child === 'object' && child !== null) {
+          this._traverseAST(child, callback);
+        }
+      }
+    }
+  }
+}
+
+module.exports = { Fix };