mm_eslint 1.4.5 → 1.4.6

package/lib/detector/variable_name.js

@@ -0,0 +1,286 @@
+const { Name } = require('./name.js');
+
+/**
+ * 变量名检测器类
+ * 负责检测变量名是否符合命名规范
+ */
+class VariableName extends Name {
+  constructor(context, config) {
+    super(context, config);
+  }
+}
+
+/**
+ * 变量声明节点检测函数
+ * @param {Object} node - 变量声明节点
+ * @returns {Object|undefined} - 检测结果对象或undefined
+ */
+VariableName.prototype.VariableDeclaration = function (node) {
+  // 检测变量声明（let 和 var）
+  if (node.kind === 'let' || node.kind === 'var') {
+    for (let i = 0; i < node.declarations.length; i++) {
+      let decl = node.declarations[i];
+      if (decl.id && decl.id.type === 'Identifier') {
+        // 排除对象字面量（ObjectExpression）
+        if (decl.init && decl.init.type === 'ObjectExpression') {
+          continue;
+        }
+
+        // 排除数组字面量（ArrayExpression）
+        if (decl.init && decl.init.type === 'ArrayExpression') {
+          continue;
+        }
+
+        // 排除类实例：如果右边是 new 表达式，则不是变量
+        if (decl.init && decl.init.type === 'NewExpression') {
+          continue;
+        }
+
+        // 排除正则表达式字面量（RegExp实例）
+        if (decl.init && decl.init.type === 'Literal' && decl.init.regex) {
+          continue;
+        }
+
+        // 排除函数：如果右边是函数表达式或箭头函数，则不是变量
+        if (decl.init && (decl.init.type === 'FunctionExpression' || decl.init.type === 'ArrowFunctionExpression')) {
+          continue;
+        }
+
+        // 排除类：如果右边是类表达式，则不是变量
+        if (decl.init && decl.init.type === 'ClassExpression') {
+          continue;
+        }
+
+        // 检测变量名
+        let name = decl.id.name;
+        
+        // 使用精确的类型识别逻辑
+        let original_type = this._getOriginalType(decl, 'VariableDeclaration');
+        
+        // 只有当确实是变量时才进行变量命名规则检测
+        if (original_type === 'variable' || original_type === 'unknown') {
+          let error = this.check(node, name, original_type);
+          
+          // 如果检测到错误，报告错误
+          if (error) {
+            this.report(node, error, original_type);
+            return error;
+          }
+        }
+      }
+    }
+  }
+}
+
+// /**
+//  * 标识符引用节点检测函数（变量引用）
+//  * @param {Object} node - 标识符节点
+//  * @returns {Object|undefined} - 检测结果对象或undefined
+//  */
+// VariableName.prototype.Identifier = function (node) {
+//   // 检测标识符引用（如表达式中的 Name、Age）
+//   if (node.type === 'Identifier') {
+//     let name = node.name;
+    
+//     // 使用精确的类型识别逻辑
+//     let original_type = this._getOriginalType(node, 'Identifier');
+    
+//     // 只有当确实是变量引用时才进行变量命名规则检测
+//     if (original_type === 'variable' || original_type === 'unknown') {
+//       let error = this.check(node, name, original_type);
+      
+//       // 如果检测到错误，报告错误
+//       if (error) {
+//         this.report(node, error, original_type);
+//         return error;
+//       }
+//     }
+//   }
+// };
+
+/**
+ * 属性节点检测函数（变量属性）
+ * @param {Object} node - 属性节点
+ * @returns {Object|undefined} - 检测结果对象或undefined
+ */
+VariableName.prototype.Property = function (node) {
+  // 判断右边是否为变量值
+  if (node.key && node.key.type === 'Identifier') {
+    // 排除类实例：如果右边是 new 表达式，则不是变量属性
+    if (node.value && node.value.type === 'NewExpression') {
+      return;
+    }
+
+    // 排除函数：如果右边是函数表达式或箭头函数，则不是变量属性
+    if (node.value && (node.value.type === 'FunctionExpression' || node.value.type === 'ArrowFunctionExpression')) {
+      return;
+    }
+
+    // 排除类：如果右边是类表达式，则不是变量属性
+    if (node.value && node.value.type === 'ClassExpression') {
+      return;
+    }
+
+    // 排除对象字面量（ObjectExpression）
+    if (node.value && node.value.type === 'ObjectExpression') {
+      return;
+    }
+
+    // 排除数组字面量（ArrayExpression）
+    if (node.value && node.value.type === 'ArrayExpression') {
+      return;
+    }
+
+    // 排除正则表达式字面量（RegExp实例）
+    if (node.value && node.value.type === 'Literal' && node.value.regex) {
+      return;
+    }
+
+    // 对于对象字面量的属性简写（property shorthand），使用属性命名风格规则
+    // 例如：{ firstName, lastName } 中的 firstName 和 lastName
+    if (node.shorthand && node.value && node.value.type === 'Identifier') {
+      // 属性简写应该使用属性命名风格规则
+      let name = node.key.name;
+      let error = this.check(node, name, 'property');
+      this.report(node, error, 'property');
+      return error;
+    }
+
+    // 使用 _getOriginalType 方法判断属性值的类型
+    // 只有当属性值是变量时，才检测属性名
+    let original_type = this._getOriginalType(node, 'Property');
+    
+    // 检查属性是否在常量对象中，如果是则跳过变量检测
+    if (this._isInConstantObject(node)) {
+      return;
+    }
+    
+    if (original_type === 'variable') {
+      let name = node.key.name;
+      let error = this.check(node, name, 'property-variable');
+      this.report(node, error, 'property-variable');
+      return error;
+    }
+    return;
+  }
+}
+
+/**
+ * 属性定义节点检测函数（类属性）
+ * @param {Object} node - 属性定义节点
+ * @returns {Object|undefined} - 检测结果对象或undefined
+ */
+VariableName.prototype.PropertyDefinition = function (node) {
+  // 排除类实例、函数、类表达式
+  if (node.value && (node.value.type === 'NewExpression' || node.value.type === 'FunctionExpression' || node.value.type === 'ArrowFunctionExpression' || node.value.type === 'ClassExpression' || node.value.type === 'ObjectExpression' || node.value.type === 'ArrayExpression' || node.value.regex)) {
+    return;
+  }
+
+  // 检测属性定义（类属性）
+  if (node.key && node.key.type === 'Identifier') {
+    let name = node.key.name;
+    let type = this._getOriginalType(node, 'PropertyDefinition');
+    if (type === 'variable') {
+      let original_type = 'property-variable';
+      if (node.static) {
+        original_type = 'static-variable';
+      }
+      else if (node.key.type === 'PrivateIdentifier') {
+        original_type = 'private-variable';
+      }
+      else if (name.startsWith('_')) {
+        original_type = 'internal-variable';
+      }
+      let error = this.check(node, name, original_type);
+      this.report(node, error, original_type);
+      return error;
+    }
+  }
+}
+
+
+/**
+ * 方法定义节点检测函数（getter/setter访问器）
+ * @param {Object} node - 方法定义节点
+ * @returns {Object|undefined} - 检测结果对象或undefined
+ */
+VariableName.prototype.MethodDefinition = function (node) {
+  // 处理getter和setter访问器（都应该按照属性处理）
+  if ((node.kind === 'get' || node.kind === 'set') && node.key && node.key.type === 'Identifier') {
+    let name = node.key.name;
+    let original_type = 'property-variable';
+    if (node.static) {
+      original_type = 'static-variable';
+    }
+    else if (node.key.type === 'PrivateIdentifier') {
+      original_type = 'private-variable';
+    }
+    else if (name.startsWith('_')) {
+      original_type = 'internal-variable';
+    }
+    let error = this.check(node, name, original_type);
+    this.report(node, error, original_type);
+    return error;
+  }
+}
+
+/**
+ * 默认导出节点检测函数（变量导出）
+ * @param {Object} node - 默认导出节点
+ * @returns {Object|undefined} - 检测结果对象或undefined
+ */
+VariableName.prototype.ExportDefaultDeclaration = function (node) {
+  // 检测导出的对象名
+  if (node.declaration && node.declaration.type === 'Identifier') {
+    let type = this._getOriginalType(node.declaration, 'ExportDefaultDeclaration');
+    if (type === 'variable') {
+      let name = node.declaration.name;
+      let original_type = 'export-variable';
+      let error = this.check(node.declaration, name, original_type);
+      this.report(node.declaration, error, original_type);
+      return error;
+    }
+  }
+}
+
+/**
+ * 命名导出节点检测函数（变量导出）
+ * @param {Object} node - 命名导出节点
+ * @returns {Object|undefined} - 检测结果对象或undefined
+ */
+VariableName.prototype.ExportNamedDeclaration = function (node) {
+  // 检测命名导出的函数引用
+  if (node.specifiers && node.specifiers.length > 0) {
+    for (let i = 0; i < node.specifiers.length; i++) {
+      let specifier = node.specifiers[i];
+
+      // 检测导出的标识符（避免重复检测）
+      // 优先检测 exported 属性，如果存在则使用它，否则使用 local 属性
+      let identifier_to_check = null;
+      let identifier_name = '';
+      
+      if (specifier.exported && specifier.exported.type === 'Identifier') {
+        identifier_to_check = specifier.exported;
+        identifier_name = specifier.exported.name;
+      } else if (specifier.local && specifier.local.type === 'Identifier') {
+        identifier_to_check = specifier.local;
+        identifier_name = specifier.local.name;
+      }
+      
+      // 只有当找到有效标识符时才进行检测
+      if (identifier_to_check) {
+        let original_type = this._getOriginalType(specifier, 'ExportSpecifier');
+
+        // 只有当导出的是变量时才检测
+        if (original_type === 'variable') {
+          let error = this.check(identifier_to_check, identifier_name, 'export-variable');
+          this.report(identifier_to_check, error, 'export-variable');
+        }
+      }
+    }
+  }
+}
+
+module.exports = {
+  VariableName
+};

package/lib/fix/class_fix.js

@@ -0,0 +1,83 @@
+/**
+ * 类相关修复函数
+ * 负责处理类声明、类表达式等AST节点的修复逻辑
+ */
+class ClassFix {
+  /**
+   * 构造函数
+   * @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} node AST节点
+   * @param {string} name 名称
+   * @returns {object|null} 标识符节点
+   */
+  _findIdentifierNode(node, name) {
+    // 如果是标识符节点且名称匹配
+    if (node.type === 'Identifier' && node.name === name) {
+      return node;
+    }
+    
+    // 如果是类声明，检查类名标识符
+    if (node.type === 'ClassDeclaration' && node.id && node.id.type === 'Identifier' && node.id.name === name) {
+      return node.id;
+    }
+    
+    // 如果是类表达式，检查类名标识符
+    if (node.type === 'ClassExpression' && node.id && node.id.type === 'Identifier' && node.id.name === name) {
+      return node.id;
+    }
+    
+    return null;
+  }
+}
+
+module.exports = { ClassFix };

package/lib/fix/export_fix.js

@@ -0,0 +1,169 @@
+/**
+ * 导出相关修复函数
+ * 负责处理导出语句中的引用修复逻辑
+ */
+class ExportFix {
+  /**
+   * 构造函数
+   * @param {object} config 配置对象
+   */
+  constructor(config) {
+    this.config = config;
+  }
+
+  /**
+   * 修复导出语句中的引用
+   * @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) {
+      // 处理 ES6 export { name } 形式的导出
+      if (child_node.type === 'ExportNamedDeclaration' &&
+          child_node.specifiers && child_node.specifiers.length > 0) {
+        
+        for (var i = 0; i < child_node.specifiers.length; i++) {
+          var specifier = child_node.specifiers[i];
+          
+          // 处理普通导出（如 export { className }）
+          if (specifier.local && specifier.local.type === 'Identifier' && 
+              specifier.local.name === old_name) {
+            fixes.push(fixer.replaceText(specifier.local, new_name));
+          }
+          
+          // 处理重命名导出（如 export { className as ClassName }）
+          if (specifier.exported && specifier.exported.type === 'Identifier' && 
+              specifier.exported.name === old_name) {
+            fixes.push(fixer.replaceText(specifier.exported, new_name));
+          }
+        }
+      }
+      
+      // 处理 ES6 export default name 形式的导出
+      if (child_node.type === 'ExportDefaultDeclaration' &&
+          child_node.declaration && child_node.declaration.type === 'Identifier' &&
+          child_node.declaration.name === old_name) {
+        
+        fixes.push(fixer.replaceText(child_node.declaration, new_name));
+      }
+      
+      // 处理 ES6 export const name = ... 形式的导出
+      if (child_node.type === 'ExportNamedDeclaration' &&
+          child_node.declaration && child_node.declaration.type === 'VariableDeclaration') {
+        
+        for (var i = 0; i < child_node.declaration.declarations.length; i++) {
+          var declaration = child_node.declaration.declarations[i];
+          if (declaration.id && declaration.id.type === 'Identifier' && 
+              declaration.id.name === old_name) {
+            fixes.push(fixer.replaceText(declaration.id, new_name));
+          }
+        }
+      }
+      
+      // 处理 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 = { ExportFix };

package/lib/fix/function_fix.js

@@ -0,0 +1,85 @@
+/**
+ * 函数相关修复函数
+ * 负责处理函数声明、函数表达式、箭头函数等AST节点的修复逻辑
+ */
+class FunctionFix {
+  /**
+   * 构造函数
+   * @param {object} config 配置对象
+   */
+  constructor(config) {
+    this.config = config;
+  }
+
+  /**
+   * 创建函数修复函数
+   * @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} node AST节点
+   * @param {string} name 名称
+   * @returns {object|null} 标识符节点
+   */
+  _findIdentifierNode(node, name) {
+    // 如果是标识符节点且名称匹配
+    if (node.type === 'Identifier' && node.name === name) {
+      return node;
+    }
+    
+    // 如果是函数声明，检查函数名标识符
+    if ((node.type === 'FunctionDeclaration' || node.type === 'FunctionExpression') && 
+        node.id && node.id.type === 'Identifier' && node.id.name === name) {
+      return node.id;
+    }
+    
+    return null;
+  }
+}
+
+module.exports = { FunctionFix };

package/lib/fix/index.js

@@ -0,0 +1,21 @@
+/**
+ * 修复模块索引文件
+ * 统一导出所有修复类
+ */
+const { ClassFix } = require('./class_fix.js');
+const { VariableFix } = require('./variable_fix.js');
+const { FunctionFix } = require('./function_fix.js');
+const { PropertyFix } = require('./property_fix.js');
+const { MethodFix } = require('./method_fix.js');
+const { ParamFix } = require('./param_fix.js');
+const { ExportFix } = require('./export_fix.js');
+
+module.exports = {
+  ClassFix,
+  VariableFix,
+  FunctionFix,
+  PropertyFix,
+  MethodFix,
+  ParamFix,
+  ExportFix
+};