mm_eslint 1.4.5 → 1.4.7

package/lib/detector/object_name.js

@@ -0,0 +1,245 @@
+const { Name } = require('./name.js');
+
+/**
+ * 变量名检测器类
+ * 负责检测变量名是否符合命名规范
+ */
+class ObjectName extends Name {
+  constructor(context, config) {
+    super(context, config);
+  }
+}
+
+/**
+ * 对象声明节点检测函数
+ * @param {Object} node - 对象声明节点
+ * @returns {Object|undefined} - 检测结果对象或undefined
+ */
+ObjectName.prototype.VariableDeclaration = function (node) {
+  // 检测变量声明（let 和 var）
+  if (node.kind === 'let' || node.kind === 'var') {
+    // 如果右边是对象或数组字面量（ObjectExpression），则是对象
+    if (node.type === 'ObjectExpression' || node.type === 'ArrayExpression') {
+      // 检测变量名
+      let name = node.id.name;
+      let original_type = 'object';
+      let error = this.check(node.id, name, original_type);
+      this.report(node.id, error, original_type);
+
+      if (error) {
+        return error;
+      }
+    }
+
+    for (let i = 0; i < node.declarations.length; i++) {
+      let decl = node.declarations[i];
+      if (decl.id && decl.id.type === 'Identifier') {
+        // 排除类实例：如果右边是 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;
+        }
+
+        // 排除基本类型字面量：布尔值、数字、字符串等
+        if (decl.init && decl.init.type === 'Literal') {
+          continue;
+        }
+
+        // 检测变量名（仅处理真正的对象类型）
+        let name = decl.id.name;
+        let original_type = 'object';
+        let error = this.check(decl.id, name, original_type);
+        this.report(decl.id, error, original_type);
+
+        if (error) {
+          return error;
+        }
+      }
+    }
+  }
+}
+
+/**
+ * 属性节点检测函数（对象属性）
+ * @param {Object} node - 属性节点
+ * @returns {Object|undefined} - 检测结果对象或undefined
+ */
+ObjectName.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;
+    }
+
+    // 排除正则表达式字面量（RegExp实例）
+    if (node.value && node.value.type === 'Literal' && node.value.regex) {
+      return;
+    }
+
+    // 如果右边是对象字面量（ObjectExpression）或数组字面量（ArrayExpression），则是对象
+    if (node.value && (node.value.type === 'ObjectExpression' || node.value.type === 'ArrayExpression')) {
+      // 检查属性是否在常量对象中，如果是则跳过对象检测（由常量检测器处理）
+      if (this._isInConstantObject(node)) {
+        return;
+      }
+      
+      let name = node.key.name;
+      let error = this.check(node, name, 'property-object');
+      this.report(node, error, 'property-object');
+      return error;
+    }
+    else {
+      // 使用 _getOriginalType 方法判断属性值的类型
+      // 只有当属性值是变量时，才检测属性名
+      let original_type = this._getOriginalType(node, 'Property');
+      if (original_type === 'object') {
+        let name = node.key.name;
+        let error = this.check(node, name, 'property-object');
+        this.report(node, error, 'property-object');
+        return error;
+      }
+      else if (original_type === 'unknown') {
+        let name = node.key.name;
+        let error = this.check(node, name, 'property');
+        this.report(node, error, 'property');
+        return error;
+      }
+    }
+    return;
+  }
+}
+
+/**
+ * 属性定义节点检测函数（类属性）
+ * @param {Object} node - 属性定义节点
+ * @returns {Object|undefined} - 检测结果对象或undefined
+ */
+ObjectName.prototype.PropertyDefinition = function (node) {
+  // 如果右边是对象或数组字面量（ObjectExpression），则是对象属性
+  if (node.value && (node.value.type === 'ObjectExpression' || node.value.type === 'ArrayExpression')) {
+    let name = node.key.name;
+    let error = this.check(node, name, 'property-object');
+    this.report(node, error, 'property-object');
+    return error;
+  }
+
+  // 排除类实例、函数、类表达式
+  if (node.value && (node.value.type === 'NewExpression' || node.value.type === 'FunctionExpression' || node.value.type === 'ArrowFunctionExpression' || node.value.type === 'ClassExpression')) {
+    return;
+  }
+
+  // 检测属性定义（类属性）
+  if (node.key && node.key.type === 'Identifier') {
+    let name = node.key.name;
+    let type = this._getOriginalType(node, 'PropertyDefinition');
+    if (type === 'object') {
+      let original_type = 'property-object';
+      if (node.static) {
+        original_type = 'static-object';
+      }
+      else if (node.key.type === 'PrivateIdentifier') {
+        original_type = 'private-object';
+      }
+      else if (name.startsWith('_')) {
+        original_type = 'internal-object';
+      }
+      let error = this.check(node, name, original_type);
+      this.report(node, error, original_type);
+      return error;
+    }
+    else if (type === 'unknown') {
+      let name = node.key.name;
+      let error = this.check(node, name, 'property');
+      this.report(node, error, 'property');
+      return error;
+    }
+  }
+}
+
+
+
+/**
+ * 默认导出节点检测函数（对象导出）
+ * @param {Object} node - 默认导出节点
+ * @returns {Object|undefined} - 检测结果对象或undefined
+ */
+ObjectName.prototype.ExportDefaultDeclaration = function (node) {
+  // 检测导出的对象名
+  if (node.declaration && node.declaration.type === 'Identifier') {
+    let type = this._getOriginalType(node.declaration, 'ExportDefaultDeclaration');
+    if (type === 'object') {
+      let name = node.declaration.name;
+      let original_type = 'export-object';
+      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
+ */
+ObjectName.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 === 'object') {
+          let error = this.check(identifier_to_check, identifier_name, 'export-object');
+          this.report(identifier_to_check, error, 'export-object');
+        }
+      }
+    }
+  }
+}
+
+module.exports = {
+  ObjectName
+};

package/lib/detector/param_name.js

@@ -0,0 +1,247 @@
+const { Name } = require('./name.js');
+
+/**
+ * 参数名检测器类
+ * 负责检测参数名是否符合命名规范
+ */
+class ParamName extends Name {
+  constructor(context, config) {
+    super(context, config);
+  }
+}
+
+/**
+ * 函数声明节点检测函数（参数检测）
+ * @param {Object} node - 函数声明节点
+ * @returns {Object|undefined} - 检测结果对象或undefined
+ */
+ParamName.prototype.FunctionDeclaration = function (node) {
+  // 检测函数参数
+  if (node.params && node.params.length > 0) {
+    for (let i = 0; i < node.params.length; i++) {
+      let param = node.params[i];
+      if (param.type === 'Identifier') {
+        let name = param.name;
+        // 根据函数体内的使用方式判断参数类型
+        let original_type = this._getParameterType(node, param);
+        if (original_type === 'unknown') {
+          original_type = 'param';
+        }
+        let error = this.check(param, name, original_type);
+        this.report(param, error, original_type);
+
+        if (error) {
+          return error;
+        }
+      }
+    }
+  }
+}
+
+/**
+ * 函数表达式节点检测函数（参数检测）
+ * @param {Object} node - 函数表达式节点
+ * @returns {Object|undefined} - 检测结果对象或undefined
+ */
+ParamName.prototype.FunctionExpression = function (node) {
+  // 检测函数参数
+  if (node.params && node.params.length > 0) {
+    for (let i = 0; i < node.params.length; i++) {
+      let param = node.params[i];
+      if (param.type === 'Identifier') {
+        let name = param.name;
+        // 根据函数体内的使用方式判断参数类型
+        let original_type = this._getParameterType(node, param);
+        if (original_type === 'unknown') {
+          original_type = 'param';
+        }
+        let error = this.check(param, name, original_type);
+        this.report(param, error, original_type);
+
+        if (error) {
+          return error;
+        }
+      }
+    }
+  }
+}
+
+/**
+ * 箭头函数表达式节点检测函数（参数检测）
+ * @param {Object} node - 箭头函数表达式节点
+ * @returns {Object|undefined} - 检测结果对象或undefined
+ */
+ParamName.prototype.ArrowFunctionExpression = function (node) {
+  // 检测箭头函数参数
+  if (node.params && node.params.length > 0) {
+    for (let i = 0; i < node.params.length; i++) {
+      let param = node.params[i];
+      if (param.type === 'Identifier') {
+        let name = param.name;
+        // 根据函数体内的使用方式判断参数类型
+        let original_type = this._getParameterType(node, param);
+        if (original_type === 'unknown') {
+          original_type = 'param';
+        }
+        let error = this.check(param, name, original_type);
+        this.report(param, error, original_type);
+
+        if (error) {
+          return error;
+        }
+      }
+    }
+  }
+}
+
+/**
+ * 方法定义节点检测函数（参数检测）
+ * @param {Object} node - 方法定义节点
+ * @returns {Object|undefined} - 检测结果对象或undefined
+ */
+ParamName.prototype.MethodDefinition = function (node) {
+  // 检测类方法参数
+  if (node.value && node.value.params && node.value.params.length > 0) {
+    for (let i = 0; i < node.value.params.length; i++) {
+      let param = node.value.params[i];
+      if (param.type === 'Identifier') {
+        let name = param.name;
+        // 根据函数体内的使用方式判断参数类型
+        let original_type = this._getParameterType(node.value, param);
+        if (original_type === 'unknown') {
+          original_type = 'param';
+        }
+        let error = this.check(node, name, original_type);
+        this.report(node, error, original_type);
+
+        if (error) {
+          return error;
+        }
+      }
+    }
+  }
+}
+
+/**
+ * 新表达式节点检测函数（参数检测）
+ * @param {Object} node - 新表达式节点
+ * @returns {Object|undefined} - 检测结果对象或undefined
+ */
+ParamName.prototype.NewExpression = function (node) {
+  // 检测新表达式中的参数
+  if (node.arguments && node.arguments.length > 0) {
+    for (let i = 0; i < node.arguments.length; i++) {
+      let arg = node.arguments[i];
+      if (arg.type === 'Identifier') {
+        let name = arg.name;
+        let original_type = 'param';
+        let error = this.check(node, name, original_type);
+        this.report(node, error, original_type);
+
+        if (error) {
+          return error;
+        }
+      }
+    }
+  }
+}
+
+/**
+ * 根据函数体内的使用方式判断参数类型
+ * @param {Object} node - 函数节点
+ * @param {Object} param - 参数节点
+ * @returns {string} 参数类型
+ */
+ParamName.prototype._getParameterType = function (node, param) {
+  const param_name = param.name;
+
+  // 如果没有函数体，默认返回基本参数类型
+  if (!node.body || !node.body.body) {
+    return 'param';
+  }
+
+  // 遍历函数体内的语句，分析参数的使用方式
+  const statements = node.body.body;
+  let is_function = false;
+  let is_class = false;
+  let is_class_instance = false;
+  let is_object = false;
+
+  // 如果statements不是数组，直接返回基本参数类型
+  if (!Array.isArray(statements)) {
+    return 'param';
+  }
+
+  // 使用Set来避免循环引用
+  const visited = new Set();
+
+  // 递归遍历AST节点
+  const traverse = (ast_node) => {
+    if (!ast_node || visited.has(ast_node)) return;
+    visited.add(ast_node);
+
+    // 检查是否作为函数调用
+    if (ast_node.type === 'CallExpression' &&
+      ast_node.callee &&
+      ast_node.callee.type === 'Identifier' &&
+      ast_node.callee.name === param_name) {
+      is_function = true;
+      return;
+    }
+
+    // 检查是否作为类实例化
+    if (ast_node.type === 'NewExpression' &&
+      ast_node.callee &&
+      ast_node.callee.type === 'Identifier' &&
+      ast_node.callee.name === param_name) {
+      is_class = true;
+      return;
+    }
+
+    // 检查是否作为对象使用（访问属性）
+    if (ast_node.type === 'MemberExpression' &&
+      ast_node.object &&
+      ast_node.object.type === 'Identifier' &&
+      ast_node.object.name === param_name) {
+      is_object = true;
+    }
+
+    // 递归遍历子节点，只遍历特定的属性
+  const keys_to_traverse = ['body', 'expression', 'declaration', 'declarations', 'init', 'test', 'consequent', 'alternate', 'argument', 'arguments', 'object', 'property', 'left', 'right', 'elements', 'properties', 'key', 'value', 'id', 'params', 'param', 'specifiers', 'exported', 'local', 'block', 'handler', 'finalizer', 'cases', 'discriminant', 'quasi', 'expressions', 'tag', 'quasis', 'cooked', 'raw', 'regex', 'flags', 'pattern', 'extra', 'rawValue', 'comments', 'leadingComments', 'trailingComments', 'innerComments'];
+
+  for (let key of keys_to_traverse) {
+    try {
+      if (ast_node[key] && typeof ast_node[key] === 'object') {
+        if (Array.isArray(ast_node[key])) {
+          ast_node[key].forEach(traverse);
+        } else {
+          traverse(ast_node[key]);
+        }
+      }
+    } catch (error) {
+      // 忽略访问受限属性的错误
+      continue;
+    }
+  }
+  };
+
+  // 遍历函数体内的所有语句
+  statements.forEach(traverse);
+
+  // 根据使用方式确定参数类型
+  if (is_class) {
+    return 'param-class';
+  } else if (is_function) {
+    return 'param-function';
+  } else if (is_class_instance) {
+    return 'param-class-instance';
+  } else if (is_object) {
+    return 'param-object';
+  } else {
+    return 'param';
+  }
+}
+
+module.exports = {
+  ParamName
+};