mm_eslint 1.1.8 → 1.2.0

package/index.js

@@ -205,6 +205,10 @@ class Detector {
       function: [
         "middleware", "controller", "component", "repository", "validator",
         "transformer", "serializer", "interceptor", "decorator", "provider"
+      ],
+      variable: [
+        "middleware", "controller", "component", "repository", "validator",
+        "transformer", "serializer", "interceptor", "decorator", "provider"
       ]
     },
     
@@ -368,10 +372,7 @@ class Detector {
         "snake_case",
         "_snake_case",
         "UPPERCASE",
-        "UPPER_SNAKE_CASE",
-        "PascalCase",
-        "camelCase",
-        "_camelCase"
+        "UPPER_SNAKE_CASE"
       ],
       strong: true, // 强验证模式：根据属性值类型智能判断；false：弱验证模式：只需符合变量名或常量名规则
     },
@@ -765,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("属性名不能为空");
   }
@@ -785,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);
@@ -830,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;
@@ -852,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;
@@ -899,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
@@ -926,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}（值）必须符合变量或常量命名规则`);
 };
 
 /**
@@ -1005,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" ||
@@ -1028,14 +1054,24 @@ Detector.prototype._getPropType = function (val_node, prop_name) {
   }
 
   // 检查是否为类
-  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)) {
@@ -1075,6 +1111,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
@@ -1586,6 +1674,8 @@ Detector.prototype._isIgnoreWord = function (name, rule_type) {
     ignore_list = ignore_words_config.method || [];
   } else if (rule_type === "function-name") {
     ignore_list = ignore_words_config.function || [];
+  } else if (rule_type === "variable-name") {
+    ignore_list = ignore_words_config.variable || [];
   }
 
   // 检查名称是否完全匹配忽略词列表中的任何一个词
@@ -1984,6 +2074,13 @@ const variable_name_rule = {
           single_word: { type: "boolean" },
           single_word_len: { type: "number" },
           styles: { type: "array", items: { type: "string" } },
+          ignore_words: {
+            type: "object",
+            properties: {
+              variable: { type: "array", items: { type: "string" } }
+            },
+            additionalProperties: false
+          }
         },
         additionalProperties: false,
       },
@@ -2349,7 +2446,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) => {
@@ -2592,9 +2689,9 @@ const instance_property_rule = {
           !node.left.property.name.startsWith("_")
         ) {
           const prop_name = node.left.property.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.right, node);
 
           if (!result.valid) {
             result.errors.forEach((error) => {
@@ -2615,9 +2712,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.8",
+  "version": "1.2.0",
   "description": "ESLint plugin for naming conventions - PascalCase, camelCase, snake_case, and UPPER_SNAKE_CASE naming rules",
   "main": "index.js",
   "keywords": [