mm_eslint 1.4.4 → 1.4.6

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/lib/tip.js

@@ -0,0 +1,85 @@
+var { Config } = require('./config');
+var { Corrector } = require('./corrector');
+var corrector = new Corrector();
+
+/**
+ * 提示管理类
+ * 统一管理所有错误提示和建议使用词的生成
+ */
+class Tip {
+  /**
+   * 构造函数
+   * @param {object} config 配置对象
+   */
+  constructor(config) {
+    this.config = config || new Config();
+  }
+}
+
+/**
+ * 生成完整的错误提示
+ * @param {object} error 错误信息
+ * @param {string} fix_suggestion 修正建议
+ * @returns {string} 完整的错误提示
+ */
+Tip.prototype.getFullMessage = function(error, fix_suggestion) {
+  var base_message = this._getBaseMessage(error);
+  var suggestion = fix_suggestion || corrector.getSuggestion(error);
+  if (suggestion) {
+    return base_message + '，建议使用：' + suggestion;
+  }
+
+  return base_message;
+};
+
+/**
+ * 获取声明方式问题的错误消息
+ * @param {string} issue_type 问题类型
+ * @param {string} name 名称
+ * @returns {string} 错误消息
+ */
+Tip.prototype.getDeclarationIssueMessage = function(issue_type, name) {
+  switch (issue_type) {
+    case 'const-should-be-let':
+      return `变量'${name}'应该用let声明而不是const`;
+    default:
+      return `变量'${name}'声明方式不符合规范`;
+  }
+};
+
+/**
+ * 获取基础错误消息
+ * @param {object} error 错误信息对象
+ * @returns {string} 基础错误消息
+ */
+Tip.prototype._getBaseMessage = function(error) {
+  var type_name_map = this.config.getTypeNameMap();
+  var name = error.name;
+  var original_type = error.original_type || 'variable';
+  var type_name = type_name_map[original_type] || '名称';
+
+  switch (error.type) {
+    case 'style':
+      var styles = error.rule.styles.join('、');
+      return `${type_name}'${name}'命名不符合${styles}风格`;
+
+    case 'length':
+      if (error.min_length) {
+        return `${type_name}'${name}'小于最小长度${error.min_length}字符`;
+      } else {
+        return `${type_name}'${name}'超过最大长度${error.max_length}字符`;
+      }
+
+    case 'word_length':
+      var word = error.word || name;
+      return `${type_name}'${name}'拼接单词"${word}"超过最大长度${error.max_word_length}字符`;
+
+    case 'forbidden_word':
+      return `${type_name}'${name}'拼接了禁用词"${error.forbidden_word}"`;
+
+    default:
+      return `${type_name}'${name}'不符合命名规范`;
+  }
+};
+
+module.exports = { Tip };

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-', '');
+  return this.config.getType(original_type);
 };
 
 /**
@@ -218,9 +218,9 @@ Validator.prototype._validateForbiddenWords = function (words, forbidden_words)
   if (!forbidden_words || forbidden_words.length === 0) {
     return null;
   }
-  for (var i = 0; i < forbidden_words.length; i++) {
-    var forbidden_word = forbidden_words[i];
-    let word = this.getForbiddenWord(words, forbidden_word.toLowerCase());
+
+  for (var i = 0; i < words.length; i++) {
+    let word = this.getForbiddenWord(forbidden_words, words[i]);
     if (word) {
       return {
         type: 'forbidden_word',
@@ -229,24 +229,20 @@ Validator.prototype._validateForbiddenWords = function (words, forbidden_words)
       };
     }
   }
-
   return null;
 };
 
 /**
  * 检查单词数组是否包含禁止拼接词
- * @param {array} words 单词数组
- * @param {string} forbidden_word 禁止拼接词
+ * @param {array} forbidden_words 禁止拼接词组
+ * @param {string} word 单词
  * @returns {boolean} 是否包含禁止拼接词
  */
-Validator.prototype.getForbiddenWord = function (words, forbidden_word) {
-  if (!words || words.length === 0) {
-    return null;
-  }
-  for (var i = 0; i < words.length; i++) {
-    var word = words[i];
+Validator.prototype.getForbiddenWord = function (forbidden_words, word) {
+  let word_lower = word.toLowerCase();
+  for (var i = 0; i < forbidden_words.length; i++) {
     // 忽略大小写进行比较
-    if (word.toLowerCase() === forbidden_word) {
+    if (forbidden_words[i].toLowerCase() === word_lower) {
       return word;
     }
   }