mm_eslint 1.1.3 → 1.1.5

package/index.js

@@ -184,6 +184,11 @@ class Detector {
         }
       }
     },
+    // 私有方法前缀列表：以这些前缀开头的方法名应该被检测为私有方法
+    private_method_prefixes: [
+      'setup', 'init', 'internal', 'private', 'helper', 'util'
+    ],
+    
     // 废话词
     forbidden_words: {
       // 类废话词：禁止在类名中使用的冗余拼接词汇（统一小写）
@@ -1777,36 +1782,55 @@ const method_name_rule = {
   },
   create(context) {
     const options = context.options[0] || {};
-    return {
-      MethodDefinition(node) {
-        const method_name = node.key.name;
-
-        // 跳过私有方法的检测（私有方法由private-naming规则处理）
-        if (method_name.startsWith("_")) {
-          return;
-        }
+    
+    function checkMethodName(node, method_name) {
+      // 跳过私有方法的检测（私有方法由private-naming规则处理）
+      if (method_name.startsWith("_")) {
+        return;
+      }
 
-        // 跳过JavaScript内置特殊方法名
-        const builtin_methods = [
-          "constructor",
-          "toString",
-          "valueOf",
-          "toJSON",
-        ];
-        if (builtin_methods.includes(method_name)) {
-          return;
-        }
+      // 跳过JavaScript内置特殊方法名
+      const builtin_methods = [
+        "constructor",
+        "toString",
+        "valueOf",
+        "toJSON",
+      ];
+      if (builtin_methods.includes(method_name)) {
+        return;
+      }
 
-        const detector = new Detector({ "method-name": options });
-        const result = detector.checkName(method_name, "method-name");
+      const detector = new Detector({ "method-name": options });
+      const result = detector.checkName(method_name, "method-name");
 
-        if (!result.valid) {
-          result.errors.forEach((error) => {
-            context.report({
-              node: node.key,
-              message: `方法名"${method_name}"不符合规范: ${error}`,
-            });
+      if (!result.valid) {
+        result.errors.forEach((error) => {
+          context.report({
+            node: node.key || node,
+            message: `方法名"${method_name}"不符合规范: ${error}`,
           });
+        });
+      }
+    }
+    
+    return {
+      // 处理类中的方法
+      MethodDefinition(node) {
+        checkMethodName(node, node.key.name);
+      },
+      
+      // 处理对象字面量中的方法
+      Property(node) {
+        // 检查是否是方法（函数表达式或箭头函数或方法简写）
+        if (node.key.type === "Identifier" && !node.key.name.startsWith("_")) {
+          const is_method = node.value && 
+            (node.value.type === "FunctionExpression" || 
+             node.value.type === "ArrowFunctionExpression" ||
+             (node.method === true)); // 方法简写语法
+          
+          if (is_method) {
+            checkMethodName(node, node.key.name);
+          }
         }
       },
     };
@@ -2063,20 +2087,18 @@ const constant_name_rule = {
     return {
       VariableDeclarator(node) {
         if (node.id.type === "Identifier" && node.parent.kind === "const") {
-          // 只对真正的常量应用常量命名规则
-          if (isRealConstant(node)) {
-            const constant_name = node.id.name;
-            const detector = new Detector({ "constant-name": options });
-            const result = detector.checkName(constant_name, "constant-name");
+          // 对所有const声明应用常量命名规则
+          const constant_name = node.id.name;
+          const detector = new Detector({ "constant-name": options });
+          const result = detector.checkName(constant_name, "constant-name");
 
-            if (!result.valid) {
-              result.errors.forEach((error) => {
-                context.report({
-                  node: node.id,
-                  message: `常量名"${constant_name}"不符合规范: ${error}`,
-                });
+          if (!result.valid) {
+            result.errors.forEach((error) => {
+              context.report({
+                node: node.id,
+                message: `常量名"${constant_name}"不符合规范: ${error}`,
               });
-            }
+            });
           }
         }
       },
@@ -2184,19 +2206,20 @@ const prop_name_rule = {
     const options = context.options[0] || {};
     return {
       Property(node) {
-        // 检测类属性、对象字面量属性、模块导出属性
-        const is_class_property =
-          node.parent &&
-          (node.parent.type === "ClassBody" ||
-            (node.parent.type === "ObjectExpression" &&
-              node.parent.parent &&
-              node.parent.parent.type === "ClassDeclaration"));
-
-        const is_object_property =
-          node.parent && node.parent.type === "ObjectExpression";
-
         // 检测所有非私有属性（不以_开头）
         if (node.key.type === "Identifier" && !node.key.name.startsWith("_")) {
+          // 检查是否是方法（函数表达式或箭头函数或方法简写）
+          const is_method = node.value && 
+            (node.value.type === "FunctionExpression" || 
+             node.value.type === "ArrowFunctionExpression" ||
+             (node.method === true)); // 方法简写语法
+          
+          // 如果是方法，跳过属性检测（方法由method-name规则处理）
+          if (is_method) {
+            return;
+          }
+          
+          // 如果是真正的属性，使用属性规则检测
           const prop_name = node.key.name;
           const detector = new Detector({ "property-name": options });
           const result = detector._checkPropName(prop_name, node.value);
@@ -2206,6 +2229,7 @@ const prop_name_rule = {
               context.report({
                 node: node.key,
                 message: `属性名"${prop_name}"不符合规范: ${error}`,
+                ruleId: "naming-convention/property-name",
               });
             });
           }
@@ -2244,23 +2268,81 @@ const private_method_rule = {
   },
   create(context) {
     const options = context.options[0] || {};
+    
+    function checkPrivateMethodName(node, method_name) {
+      const detector = new Detector({ "private-method-naming": options });
+      const result = detector.checkName(
+        method_name,
+        "private-method-naming",
+      );
+
+      if (!result.valid) {
+        result.errors.forEach((error) => {
+          context.report({
+            node: node.key || node,
+            message: `私有方法名"${method_name}"不符合规范: ${error}`,
+          });
+        });
+      }
+    }
+    
+    // 检测应该是私有方法但没有_前缀的情况
+    function checkMissingPrivatePrefix(node, method_name) {
+      // 使用配置中的私有方法前缀列表
+      const detector = new Detector({ "private-method-naming": options });
+      const private_prefixes = detector.config.private_method_prefixes || [];
+      
+      // 判断是否应该是私有方法（基于前缀判断）
+      const should_be_private = private_prefixes.some(prefix => {
+        if (!method_name.toLowerCase().startsWith(prefix.toLowerCase())) {
+          return false;
+        }
+        
+        // 额外检查：只有多单词的方法名才需要是私有方法
+        // 例如：init() 可以非私有，但initService() 必须私有
+        const remaining_part = method_name.substring(prefix.length);
+        const is_multi_word = remaining_part.length > 0 && 
+                             remaining_part[0].toUpperCase() === remaining_part[0];
+        
+        return is_multi_word;
+      });
+      
+      if (should_be_private && !method_name.startsWith("_")) {
+        context.report({
+          node: node.key || node,
+          message: `方法名"${method_name}"应该是私有方法，但缺少_前缀`,
+        });
+      }
+    }
+    
     return {
+      // 处理类中的私有方法
       MethodDefinition(node) {
         const method_name = node.key.name;
         if (method_name.startsWith("_")) {
-          const detector = new Detector({ "private-method-naming": options });
-          const result = detector.checkName(
-            method_name,
-            "private-method-naming",
-          );
-
-          if (!result.valid) {
-            result.errors.forEach((error) => {
-              context.report({
-                node: node.key,
-                message: `私有方法名"${method_name}"不符合规范: ${error}`,
-              });
-            });
+          checkPrivateMethodName(node, method_name);
+        } else {
+          // 检测应该是私有方法但没有_前缀的情况
+          checkMissingPrivatePrefix(node, method_name);
+        }
+      },
+      
+      // 处理对象字面量中的私有方法
+      Property(node) {
+        if (node.key.type === "Identifier") {
+          // 检查是否是方法（函数表达式或箭头函数或方法简写）
+          const is_method = node.value && 
+            (node.value.type === "FunctionExpression" || 
+             node.value.type === "ArrowFunctionExpression" ||
+             (node.method === true)); // 方法简写语法
+          
+          if (is_method) {
+            if (node.key.name.startsWith("_")) {
+              checkPrivateMethodName(node, node.key.name);
+            } else {
+              // 检测应该是私有方法但没有_前缀的情况
+              checkMissingPrivatePrefix(node, node.key.name);
+            }
           }
         }
       },
@@ -2300,20 +2382,43 @@ const private_variable_rule = {
     return {
       Property(node) {
         if (node.key.type === "Identifier" && node.key.name.startsWith("_")) {
-          const private_name = node.key.name;
-          const detector = new Detector({ "private-variable-naming": options });
-          const result = detector.checkName(
-            private_name,
-            "private-variable-naming",
-          );
+          // 检查是否是方法（函数表达式或箭头函数）
+          const is_method = node.value && 
+            (node.value.type === "FunctionExpression" || 
+             node.value.type === "ArrowFunctionExpression");
+          
+          // 如果是方法，应该使用私有方法规则检测，而不是私有变量规则
+          if (is_method) {
+            const detector = new Detector({ "private-method-naming": options });
+            const result = detector.checkName(
+              node.key.name,
+              "private-method-naming",
+            );
 
-          if (!result.valid) {
-            result.errors.forEach((error) => {
-              context.report({
-                node: node.key,
-                message: `私有属性名"${private_name}"不符合规范: ${error}`,
+            if (!result.valid) {
+              result.errors.forEach((error) => {
+                context.report({
+                  node: node.key,
+                  message: `私有方法名"${node.key.name}"不符合规范: ${error}`,
+                });
               });
-            });
+            }
+          } else {
+            // 如果是真正的属性，使用私有变量规则检测
+            const detector = new Detector({ "private-variable-naming": options });
+            const result = detector.checkName(
+              node.key.name,
+              "private-variable-naming",
+            );
+
+            if (!result.valid) {
+              result.errors.forEach((error) => {
+                context.report({
+                  node: node.key,
+                  message: `私有属性名"${node.key.name}"不符合规范: ${error}`,
+                });
+              });
+            }
           }
         }
       },
@@ -2360,8 +2465,9 @@ const instance_property_rule = {
           !node.left.property.name.startsWith("_")
         ) {
           const prop_name = node.left.property.name;
-          const detector = new Detector({ "property-name": options });
-          const result = detector._checkPropName(prop_name, node.right);
+          // 实例属性应该符合方法命名规范（小驼峰）
+          const detector = new Detector({ "method-name": options });
+          const result = detector.checkName(prop_name, "method-name");
 
           if (!result.valid) {
             result.errors.forEach((error) => {
@@ -2373,6 +2479,29 @@ const instance_property_rule = {
           }
         }
       },
+      // 检测构造函数内的属性声明
+      PropertyDefinition(node) {
+        if (
+          node.parent && 
+          node.parent.type === "ClassBody" &&
+          node.key.type === "Identifier" &&
+          !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");
+
+          if (!result.valid) {
+            result.errors.forEach((error) => {
+              context.report({
+                node: node.key,
+                message: `实例属性名"${prop_name}"不符合规范: ${error}`,
+              });
+            });
+          }
+        }
+      },
     };
   },
 };

package/package.json

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