mm_eslint 1.4.4 → 1.4.6

package/lib/detector/class_name.js

@@ -0,0 +1,261 @@
+const { Name } = require('./name.js');
+
+/**
+ * 类名检测器类
+ * 负责检测类名是否符合命名规范
+ */
+class ClassName extends Name {
+  constructor(context, config) {
+    super(context, config);
+  }
+}
+
+/**
+ * 类声明节点检测函数
+ * @param {Object} node - 类声明节点
+ * @returns {Object|undefined} - 检测结果对象或undefined
+ */
+ClassName.prototype.ClassDeclaration = function (node) {
+  // 检测类名
+  let name = node.id.name;
+  let original_type = 'class';
+  let error = this.check(node.id, name, original_type);
+  this.report(node.id, error, original_type);
+
+  // 检测继承的父类名（如果有）
+  if (node.superClass && node.superClass.type === 'Identifier') {
+    let super_name = node.superClass.name;
+    let super_original_type = 'super-class';
+    let super_error = this.check(node.superClass, super_name, super_original_type);
+    this.report(node.superClass, super_error, super_original_type);
+    return error || super_error;
+  }
+
+  return error;
+}
+
+/**
+ * 变量声明节点检测
+ * @param {Object} node - 变量声明节点
+ * @returns {Object|undefined} - 检测结果对象或undefined
+ */
+ClassName.prototype.VariableDeclaration = function (node) {
+  // 判断右边是否有类表达式
+  if (node.declarations[0].init && node.declarations[0].init.type === 'ClassExpression') {
+    let name = node.declarations[0].id.name;
+    let original_type = 'class';
+    let error = this.check(node.declarations[0].id, name, original_type);
+    this.report(node.declarations[0].id, error, original_type);
+    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 === 'class') {
+      let name = node.declarations[0].id.name;
+      let original_type = 'class';
+      let error = this.check(node.declarations[0].id, name, original_type);
+      this.report(node.declarations[0].id, error, original_type);
+      return error;
+    }
+  }
+}
+
+/**
+ * 属性节点检测函数
+ * @param {Object} node - 属性节点
+ * @returns {Object|undefined} - 检测结果对象或undefined
+ */
+ClassName.prototype.Property = function (node) {
+  // 判断右边是否为类表达式
+  if (node.value.type === 'ClassExpression') {
+    let name = node.key.name;
+    let original_type = 'property-class';
+    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 === 'class') {
+      let name = node.key.name;
+      let original_type = 'property-class';
+      let error = this.check(node, name, original_type);
+      this.report(node, error, original_type);
+      return error;
+    }
+  }
+}
+
+/**
+ * 类表达式节点检测函数
+ * @param {Object} node - 类表达式节点
+ * @returns {Object|undefined} - 检测结果对象或undefined
+ */
+ClassName.prototype.ClassExpression = function (node) {
+  // 检测类表达式中的类名：class info {}
+  if (node.id && node.id.type === 'Identifier') {
+    let name = node.id.name;
+    let original_type = 'class';
+    let error = this.check(node, name, original_type);
+    this.report(node, error, 'class');
+    return error;
+  }
+
+  return undefined;
+}
+
+/**
+ * 新表达式节点检测函数
+ * @param {Object} node - 新表达式节点
+ * @returns {Object|undefined} - 检测结果对象或undefined
+ */
+ClassName.prototype.NewExpression = function (node) {
+  // 检测独立的新表达式：new ClassName();
+  if (node.callee && node.callee.type === 'Identifier') {
+    let name = node.callee.name;
+    let original_type = 'use-class';
+    let error = this.check(node.callee, name, original_type);
+    this.report(node.callee, error, original_type);
+    return error;
+  }
+
+  return undefined;
+}
+
+/**
+ * 赋值表达式节点检测函数
+ * @param {Object} node - 赋值表达式节点
+ * @returns {Object|undefined} - 检测结果对象或undefined
+ */
+ClassName.prototype.AssignmentExpression = function (node) {
+  // 检测 exports 或 module.exports 赋值：exports.className = className;
+  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 === 'class') {
+        let left_property = node.left.property;
+        if (left_property && left_property.type === 'Identifier') {
+          let name = left_property.name;
+          let original_type = 'property-class';
+          let error = this.check(left_property, name, original_type);
+          this.report(left_property, error, original_type);
+          return error;
+        }
+      }
+    }
+  }
+}
+
+/**
+ * 默认导出节点检测函数
+ * @param {Object} node - 默认导出节点
+ * @returns {Object|undefined} - 检测结果对象或undefined
+ */
+ClassName.prototype.ExportDefaultDeclaration = function (node) {
+  // 检测导出的类实例中的类名
+  if (node.declaration && node.declaration.type === 'NewExpression') {
+    let name = node.declaration.callee ? node.declaration.callee.name : 'AnonymousInstance';
+    let original_type = 'export-class';
+    let error = this.check(node, name, original_type);
+    this.report(node, error, original_type);
+    return error;
+  }
+
+  // 检测导出的类表达式
+  if (node.declaration && node.declaration.type === 'ClassExpression') {
+    let name = node.declaration.id ? node.declaration.id.name : 'AnonymousClass';
+    let original_type = 'export-class';
+    let error = this.check(node, name, original_type);
+    this.report(node, error, original_type);
+    return error;
+  }
+
+  // 检测导出的类名
+  if (node.declaration && node.declaration.type === 'Identifier') {
+    let name = node.declaration.name;
+    let type = this._getOriginalType(node.declaration, 'ExportDefaultDeclaration');
+    if (type === 'class') {
+      let original_type = 'export-class';
+      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
+ */
+ClassName.prototype.ExportNamedDeclaration = function (node) {
+  // 检测导出的类声明（如 export class className {}）
+  if (node.declaration && node.declaration.type === 'ClassDeclaration') {
+    let name = node.declaration.id ? node.declaration.id.name : 'AnonymousClass';
+    let error = this.check(node, name, 'export-class');
+    this.report(node, error, 'export-class');
+    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 === 'class') {
+          let error = this.check(identifier_to_check, identifier_name, 'export-class');
+          this.report(identifier_to_check, error, 'export-class');
+        }
+      }
+    }
+  }
+}
+
+module.exports = {
+  ClassName
+}