mm_eslint 1.1.9 → 1.2.1

package/index.js

@@ -372,10 +372,7 @@ class Detector {
         "snake_case",
         "_snake_case",
         "UPPERCASE",
-        "UPPER_SNAKE_CASE",
-        "PascalCase",
-        "camelCase",
-        "_camelCase"
+        "UPPER_SNAKE_CASE"
       ],
       strong: true, // 强验证模式：根据属性值类型智能判断；false：弱验证模式：只需符合变量名或常量名规则
     },
@@ -769,10 +766,11 @@ Detector.prototype._splitWords = function (name, rule_type) {
  * 属性名检查方法（根据属性值类型应用不同规则）
  * @param {string} name - 属性名
  * @param {Object} val_node - 属性值AST节点
+ * @param {Object} parent_node - 父节点AST节点（可选，用于上下文感知检测）
  * @returns {Object} 检查结果
  * @private
  */
-Detector.prototype._checkPropName = function (name, val_node) {
+Detector.prototype._checkPropName = function (name, val_node, parent_node) {
   if (!name) {
     throw new TypeError("属性名不能为空");
   }
@@ -789,7 +787,7 @@ Detector.prototype._checkPropName = function (name, val_node) {
   this._checkBadWords(name, config, errors);
 
   const use_strong_val = config.strong !== false;
-  const val_type = this._getPropType(val_node, name);
+  const val_type = this._getPropType(val_node, name, parent_node);
 
   if (use_strong_val) {
     this._checkPropStrong(name, val_type, config, errors);
@@ -834,6 +832,9 @@ Detector.prototype._checkPropStrong = function (
     case "function":
       this._checkFuncProp(name, config, errors);
       break;
+    case "method":
+      this._checkMethodProp(name, config, errors);
+      break;
     case "class":
       this._checkClassProp(name, config, errors);
       break;
@@ -856,6 +857,9 @@ Detector.prototype._checkPropWeak = function (name, val_type, config, errors) {
     case "function":
       this._checkFuncProp(name, config, errors);
       break;
+    case "method":
+      this._checkMethodProp(name, config, errors);
+      break;
     case "class":
       this._checkClassProp(name, config, errors);
       break;
@@ -903,6 +907,17 @@ Detector.prototype._checkConstProp = function (name, config, errors) {
   }
 };
 
+/**
+ * 检查方法属性
+ * @private
+ */
+Detector.prototype._checkMethodProp = function (name, config, errors) {
+  const method_res = this._checkName("method-name", name);
+  if (!method_res.valid) {
+    errors.push(`${config.name}（方法）${method_res.errors.join(", ")}`);
+  }
+};
+
 /**
  * 建议常量命名
  * @private
@@ -930,21 +945,20 @@ Detector.prototype._suggestConstName = function (name, config, errors) {
  * @private
  */
 Detector.prototype._checkValueProp = function (name, config, errors) {
-  const is_upper_snake = /^[A-Z][A-Z0-9_]*(_[A-Z0-9]+)+$/.test(name);
-  const is_upper_multi = /^[A-Z][A-Z0-9]*[A-Z][A-Z0-9]*$/.test(name);
-
-  if (is_upper_snake || is_upper_multi) {
-    errors.push(
-      `${config.name}（值）禁止使用大写蛇形命名（如PRODUCT_ID或PRODUCTID）`,
-    );
+  // 检查常量规则
+  const const_res = this._checkName("constant-name", name);
+  if (const_res.valid) {
+    return; // 满足常量规则，通过
   }
-
-  if (config.styles && config.styles.length > 0) {
-    const is_valid_style = this._checkStyle(name, config.styles);
-    if (!is_valid_style && !is_upper_snake && !is_upper_multi) {
-      this._suggestValueName(name, config, errors);
-    }
+  
+  // 检查变量规则
+  const var_res = this._checkName("variable-name", name);
+  if (var_res.valid) {
+    return; // 满足变量规则，通过
   }
+  
+  // 都不满足，报告错误
+  errors.push(`${config.name}（值）必须符合变量或常量命名规则`);
 };
 
 /**
@@ -1009,14 +1023,22 @@ Detector.prototype._checkPropSingleWord = function (name, config, warnings) {
 /**
  * 获取属性值类型
  * @param {Object} val_node - 属性值AST节点
- * @returns {string} 属性值类型（'function', 'class', 'value'）
+ * @param {string} prop_name - 属性名
+ * @param {Object} parent_node - 父节点AST节点（可选，用于上下文感知检测）
+ * @returns {string} 属性值类型（'function', 'method', 'class', 'value'）
  * @private
  */
-Detector.prototype._getPropType = function (val_node, prop_name) {
+Detector.prototype._getPropType = function (val_node, prop_name, parent_node) {
   if (!val_node) {
     return "value"; // 默认值类型
   }
 
+  // 检查是否为对象方法（在对象字面量中的函数）
+  if (parent_node && parent_node.type === "Property" && 
+      (val_node.type === "FunctionExpression" || val_node.type === "ArrowFunctionExpression")) {
+    return "method"; // 对象方法类型
+  }
+
   // 检查是否为函数
   if (
     val_node.type === "FunctionExpression" ||
@@ -1026,20 +1048,44 @@ Detector.prototype._getPropType = function (val_node, prop_name) {
       (val_node.name.endsWith("Function") ||
         val_node.name.endsWith("Func") ||
         val_node.name.startsWith("on") ||
-        val_node.name.startsWith("handle")))
+        val_node.name.startsWith("handle") ||
+        // 新增：常见函数命名模式识别
+        val_node.name.endsWith("Manager") ||
+        val_node.name.endsWith("Admin") ||
+        val_node.name.endsWith("Handler") ||
+        val_node.name.endsWith("Service") ||
+        val_node.name.endsWith("Util") ||
+        val_node.name.endsWith("Helper") ||
+        val_node.name.endsWith("Factory") ||
+        val_node.name.endsWith("Provider") ||
+        // 检查是否为小驼峰命名（函数常见命名风格）
+        (/^[a-z][a-zA-Z0-9]*$/.test(val_node.name) && 
+         val_node.name !== val_node.name.toLowerCase() &&
+         !val_node.name.includes("_") &&
+         !val_node.name.includes("-"))))
   ) {
     return "function";
   }
 
   // 检查是否为类
-  if (
-    val_node.type === "ClassExpression" ||
-    (val_node.type === "Identifier" &&
-      val_node.name &&
-      /^[A-Z][a-zA-Z]*$/.test(val_node.name))
-  ) {
+  if (val_node.type === "ClassExpression" || val_node.type === "NewExpression") {
     return "class";
   }
+  
+  // 对于标识符类型的值，采用保守策略
+  // 只有当明显是类名时才认为是类类型
+  if (val_node.type === "Identifier" && val_node.name) {
+    // 检查标识符名称是否符合类名模式（PascalCase）
+    const is_pascal_case = /^[A-Z][a-zA-Z0-9]*$/.test(val_node.name);
+    
+    // 如果标识符名称符合PascalCase，且不是常见的配置参数名，则认为是类类型
+    const common_config_names = ['config', 'options', 'params', 'settings', 'props'];
+    const is_common_config = common_config_names.includes(val_node.name.toLowerCase());
+    
+    if (is_pascal_case && !is_common_config) {
+      return "class";
+    }
+  }
 
   // 检查是否为常量/配置值（应该使用UPPERCASE风格）
   if (this._isConst(val_node, prop_name)) {
@@ -1079,6 +1125,58 @@ Detector.prototype._isConst = function (val_node, prop_name) {
   return this._isConstWithoutName(is_prim_const, is_cfg_obj, is_const_id);
 };
 
+/**
+ * 判断标识符是否为类名（基于上下文分析）
+ * @param {string} name - 标识符名称
+ * @param {Object} context_node - 上下文AST节点
+ * @returns {boolean} 是否为类名
+ * @private
+ */
+Detector.prototype._isClassName = function (name, context_node) {
+  if (!name || typeof name !== 'string') {
+    return false;
+  }
+
+  // 首先检查是否为大驼峰命名（类名的基本要求）
+  if (!/^[A-Z][a-zA-Z]*$/.test(name)) {
+    return false;
+  }
+
+  // 如果有上下文节点，进行更精确的分析
+  if (context_node) {
+    // 检查是否在类声明中
+    if (context_node.type === 'ClassDeclaration' || 
+        context_node.type === 'ClassExpression') {
+      return true;
+    }
+    
+    // 检查是否在 extends 或 implements 中
+    if (context_node.type === 'Identifier' && 
+        context_node.parent && 
+        (context_node.parent.type === 'ClassDeclaration' || 
+         context_node.parent.type === 'ClassExpression')) {
+      return true;
+    }
+    
+    // 检查是否在 new 表达式中
+    if (context_node.type === 'NewExpression' && 
+        context_node.callee && 
+        context_node.callee.name === name) {
+      return true;
+    }
+  }
+
+  // 对于没有上下文的情况，采用保守策略
+  // 只对明显是类名的标识符返回 true
+  const class_suffixes = [
+    'Manager', 'Controller', 'Service', 'Factory', 'Builder', 
+    'Provider', 'Middleware', 'Component', 'Repository', 'Handler',
+    'Adapter', 'Decorator', 'Validator', 'Generator', 'Processor'
+  ];
+
+  return class_suffixes.some(suffix => name.endsWith(suffix));
+};
+
 /**
  * 检查是否为基本类型常量
  * @private
@@ -2362,7 +2460,7 @@ const prop_name_rule = {
           // 如果是真正的属性，使用属性规则检测
           const prop_name = node.key.name;
           const detector = new Detector({ "property-name": options });
-          const result = detector._checkPropName(prop_name, node.value);
+          const result = detector._checkPropName(prop_name, node.value, node);
 
           if (!result.valid) {
             result.errors.forEach((error) => {
@@ -2605,9 +2703,9 @@ const instance_property_rule = {
           !node.left.property.name.startsWith("_")
         ) {
           const prop_name = node.left.property.name;
-          // 实例属性应该符合变量命名规范（小写蛇形）
-          const detector = new Detector({ "variable-name": options });
-          const result = detector.checkName(prop_name, "variable-name");
+          // 实例属性应该符合属性命名规范（小写蛇形）
+          const detector = new Detector({ "property-name": options });
+          const result = detector._checkPropName(prop_name, node.right, node);
 
           if (!result.valid) {
             result.errors.forEach((error) => {
@@ -2628,9 +2726,9 @@ const instance_property_rule = {
           !node.key.name.startsWith("_")
         ) {
           const prop_name = node.key.name;
-          // 实例属性应该符合方法命名规范（小驼峰）
-          const detector = new Detector({ "method-name": options });
-          const result = detector.checkName(prop_name, "method-name");
+          // 实例属性应该符合属性命名规范（小写蛇形）
+          const detector = new Detector({ "property-name": options });
+          const result = detector._checkPropName(prop_name, node.value, node);
 
           if (!result.valid) {
             result.errors.forEach((error) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mm_eslint",
-  "version": "1.1.9",
+  "version": "1.2.1",
   "description": "ESLint plugin for naming conventions - PascalCase, camelCase, snake_case, and UPPER_SNAKE_CASE naming rules",
   "main": "index.js",
   "keywords": [