mm_eslint 1.4.4 → 1.4.6

package/lib/detector/function_name.js

@@ -0,0 +1,318 @@
+const { Name } = require('./name.js');
+
+/**
+ * 函数名检测器类
+ * 负责检测函数名是否符合命名规范
+ */
+class FunctionName extends Name {
+  constructor(context, config) {
+    super(context, config);
+  }
+}
+
+/**
+ * 函数声明节点检测函数
+ * @param {Object} node - 函数声明节点
+ * @returns {Object|undefined} - 检测结果对象或undefined
+ */
+FunctionName.prototype.FunctionDeclaration = function (node) {
+  let name = node.id.name;
+  let original_type = 'function';
+  let error = this.check(node.id, name, original_type);
+  this.report(node.id, error, 'function');
+  return error;
+}
+
+/**
+ * 函数表达式节点检测函数
+ * @param {Object} node - 函数表达式节点
+ * @returns {Object|undefined} - 检测结果对象或undefined
+ */
+FunctionName.prototype.FunctionExpression = function (node) {
+  // 检测函数表达式中的函数名
+  if (node.id && node.id.type === 'Identifier') {
+    let name = node.id.name;
+    let original_type = 'function';
+    let error = this.check(node, name, original_type);
+    this.report(node, error, 'function');
+    return error;
+  }
+}
+
+/**
+ * 变量声明节点检测函数
+ * @param {Object} node - 变量声明节点
+ * @returns {Object|undefined} - 检测结果对象或undefined
+ */
+FunctionName.prototype.VariableDeclaration = function (node) {
+  // 判断右边是否有函数表达式
+  if (node.declarations[0].init && (node.declarations[0].init.type === 'FunctionExpression' || node.declarations[0].init.type === 'ArrowFunctionExpression')) {
+    let name = node.declarations[0].id.name;
+    let original_type = 'function';
+    let error = this.check(node.declarations[0].id, name, original_type);
+    this.report(node.declarations[0].id, error, 'function');
+    return error;
+  }
+
+  // 判断右边是否直接赋值函数名
+  if (node.declarations[0].init && node.declarations[0].init.type === 'Identifier') {
+    // 根据右边值的类型决定左边变量的类型
+    let original_type = this._getOriginalType(node.declarations[0], 'VariableDeclaration');
+
+    // 如果右边是函数，左边变量应该按照函数引用的命名规范检测
+    if (original_type === 'function') {
+      let name = node.declarations[0].id.name;
+      let error = this.check(node.declarations[0].id, name, 'function');
+      this.report(node.declarations[0].id, error, 'function');
+      return error;
+    }
+  }
+}
+
+/**
+ * 属性节点检测函数（函数属性）
+ * @param {Object} node - 属性节点
+ * @returns {Object|undefined} - 检测结果对象或undefined
+ */
+FunctionName.prototype.Property = function (node) {
+  // 判断右边是否为函数表达式
+  if (node.value.type === 'FunctionExpression' || node.value.type === 'ArrowFunctionExpression') {
+    let name = node.key.name;
+    let original_type = 'property-function';
+    let error = this.check(node, name, original_type);
+    this.report(node, error, original_type);
+    return error;
+  }
+
+  // 判断右边是否直接定义为函数名
+  if (node.value.type === 'Identifier') {
+    // 根据右边值的类型决定左边属性的类型
+    let original_type = this._getOriginalType(node, 'Property');
+
+    // 如果右边是函数，左边属性应该按照函数引用的命名规范检测
+    if (original_type === 'function') {
+      let name = node.key.name;
+      let original_type = 'property-function';
+      let error = this.check(node, name, original_type);
+      this.report(node, error, original_type);
+      return error;
+    }
+  }
+}
+
+/**
+ * 类属性定义节点检测函数
+ * @param {Object} node - 类属性定义节点
+ * @returns {Object|undefined} - 检测结果对象或undefined
+ */
+FunctionName.prototype.PropertyDefinition = function (node) {
+  // 判断右边是否有 new 表达式
+  if (node.value && (node.value.type === 'FunctionExpression' || node.value.type === 'ArrowFunctionExpression')) {
+    let name = node.key.name;
+    let original_type = 'property-function';
+    if (node.static) {
+      original_type = 'static-function';
+    }
+    else if (node.key.type === 'PrivateIdentifier') {
+      original_type = 'private-function';
+    }
+    else if (name.startsWith('_')) {
+      original_type = 'internal-function';
+    }
+    let error = this.check(node, name, original_type);
+    this.report(node, error, original_type);
+    return error;
+  }
+
+  // 判断右边是否直接定义为类实例名
+  if (node.value && node.value.type === 'Identifier') {
+    // 根据右边值的类型决定左边属性的类型
+    let original_type = this._getOriginalType(node, 'PropertyDefinition');
+
+    // 如果右边是类实例，左边属性应该按照类实例的命名规范检测（小驼峰）
+    if (original_type === 'function') {
+      let name = node.key.name;
+      let original_type = 'property-function';
+      if (node.static) {
+        original_type = 'static-function';
+      }
+      else if (node.key.type === 'PrivateIdentifier') {
+        original_type = 'private-function';
+      }
+      else if (name.startsWith('_')) {
+        original_type = 'internal-function';
+      }
+      let error = this.check(node, name, original_type);
+      this.report(node, error, original_type);
+      return error;
+    }
+  }
+}
+
+/**
+ * 方法定义节点检测函数
+ * @param {Object} node - 方法定义节点
+ * @returns {Object|undefined} - 检测结果对象或undefined
+ */
+FunctionName.prototype.MethodDefinition = function (node) {
+  // 排除getter访问器（应该按照属性处理）
+  if (node.kind === 'get' || node.kind === 'set') {
+    return undefined;
+  }
+
+  // 检测类中的方法定义（普通方法）
+  if (node.key && node.key.type === 'Identifier') {
+    let name = node.key.name;
+    let original_type = 'property-function';
+    if (node.static) {
+      original_type = 'static-function';
+    }
+    else if (node.key.type === 'PrivateIdentifier') {
+      original_type = 'private-function';
+    }
+    else if (name.startsWith('_')) {
+      original_type = 'internal-function';
+    }
+    let error = this.check(node, name, original_type);
+    this.report(node, error, original_type);
+    return error;
+  }
+}
+
+/**
+ * 赋值表达式节点检测函数（函数赋值）
+ * @param {Object} node - 赋值表达式节点
+ * @returns {Object|undefined} - 检测结果对象或undefined
+ */
+FunctionName.prototype.AssignmentExpression = function (node) {
+  // 检测 exports 或 module.exports 赋值：exports.functionName = functionName;
+  if (node.operator === '=' && node.left && node.left.type === 'MemberExpression') {
+    // 检查左边是否为 exports 或 module.exports
+    let left_object = node.left.object;
+    let is_exports = false;
+
+    if (left_object.type === 'Identifier' && left_object.name === 'exports') {
+      is_exports = true;
+    } else if (left_object.type === 'MemberExpression' &&
+      left_object.object.type === 'Identifier' &&
+      left_object.object.name === 'module' &&
+      left_object.property.type === 'Identifier' &&
+      left_object.property.name === 'exports') {
+      is_exports = true;
+    }
+
+    if (is_exports && node.right && node.right.type === 'Identifier') {
+      // 先判断右边是否为函数
+      let original_type = this._getOriginalType(node, 'AssignmentExpression');
+
+      // 如果右边是函数，才检测左边的属性名
+      if (original_type === 'function') {
+        let left_property = node.left.property;
+        if (left_property && left_property.type === 'Identifier') {
+          let name = left_property.name;
+          let original_type = 'property-function';
+          let error = this.check(left_property, name, original_type);
+          this.report(left_property, error, original_type);
+          return error;
+        }
+      }
+    }
+  }
+
+  return undefined;
+}
+
+/**
+ * 调用表达式节点检测函数（函数调用）
+ * @param {Object} node - 调用表达式节点
+ * @returns {Object|undefined} - 检测结果对象或undefined
+ */
+FunctionName.prototype.CallExpression = function (node) {
+  // 检测函数调用中的函数名
+  if (node.callee && node.callee.type === 'Identifier') {
+    let name = node.callee.name;
+    let original_type = 'use-function';
+    let error = this.check(node, name, original_type);
+    this.report(node, error, original_type);
+    return error;
+  }
+}
+
+/**
+ * 默认导出节点检测函数（函数导出）
+ * @param {Object} node - 默认导出节点
+ * @returns {Object|undefined} - 检测结果对象或undefined
+ */
+FunctionName.prototype.ExportDefaultDeclaration = function (node) {
+  // 检测导出的函数表达式
+  if (node.declaration && (node.declaration.type === 'FunctionExpression' || node.declaration.type === 'ArrowFunctionExpression')) {
+    let name = node.declaration.id ? node.declaration.id.name : 'AnonymousFunction';
+    let original_type = 'export-function';
+    let error = this.check(node.declaration, name, original_type);
+    this.report(node.declaration, error, original_type);
+    return error;
+  }
+
+  // 检测导出的函数名
+  if (node.declaration && node.declaration.type === 'Identifier') {
+    let type = this._getOriginalType(node.declaration, 'ExportDefaultDeclaration');
+    if (type === 'function') {
+      let name = node.declaration.name;
+      let original_type = 'export-function';
+      let error = this.check(node.declaration, name, original_type);
+      this.report(node.declaration, error, original_type);
+      return error;
+    }
+  }
+
+  // 如果没有匹配的导出类型，返回 undefined
+  return undefined;
+}
+
+/**
+ * 命名导出节点检测函数（函数导出）
+ * @param {Object} node - 命名导出节点
+ * @returns {Object|undefined} - 检测结果对象或undefined
+ */
+FunctionName.prototype.ExportNamedDeclaration = function (node) {
+  // 检测导出的函数声明（如 export function functionName() {}）
+  if (node.declaration && node.declaration.type === 'FunctionDeclaration') {
+    let name = node.declaration.id ? node.declaration.id.name : 'AnonymousFunction';
+    let error = this.check(node, name, 'export-function');
+    this.report(node, error, 'export-function');
+    return error;
+  }
+
+  // 检测命名导出的函数引用
+  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 === 'function') {
+          let error = this.check(identifier_to_check, identifier_name, 'export-function');
+          this.report(identifier_to_check, error, 'export-function');
+        }
+      }
+    }
+  }
+}
+
+module.exports = { FunctionName }

package/lib/detector/index.js

@@ -0,0 +1,18 @@
+const { ClassName } = require('./class_name.js');
+const { ClassInstanceName } = require('./class_instance_name.js');
+const { FunctionName } = require('./function_name.js');
+const { VariableName } = require('./variable_name.js');
+const { ObjectName } = require('./object_name.js');
+const { ConstName } = require('./const_name.js');
+const { ParamName } = require('./param_name.js');
+
+
+module.exports = {
+  ClassName,
+  ClassInstanceName,
+  FunctionName,
+  VariableName,
+  ObjectName,
+  ConstName,
+  ParamName,
+}