mm_eslint 1.1.6 → 1.1.8

package/index.js

@@ -189,6 +189,25 @@ class Detector {
       'setup', 'init', 'internal', 'private', 'helper', 'util'
     ],
     
+    // 忽略词列表：这些词汇在命名检测时会被忽略，不进行长度和风格检测
+    ignore_words: {
+      // 类名忽略词：这些词汇在类名中允许使用，即使超过8个字符
+      class: [
+        "Controller", "Middleware", "Component", "Repository", "Validator",
+        "Transformer", "Serializer", "Interceptor", "Decorator", "Provider"
+      ],
+      // 方法名忽略词：这些词汇在方法名中允许使用，即使超过8个字符
+      method: [
+        "middleware", "controller", "component", "repository", "validator",
+        "transformer", "serializer", "interceptor", "decorator", "provider"
+      ],
+      // 函数名忽略词：这些词汇在函数名中允许使用，即使超过8个字符
+      function: [
+        "middleware", "controller", "component", "repository", "validator",
+        "transformer", "serializer", "interceptor", "decorator", "provider"
+      ]
+    },
+    
     // 废话词
     forbidden_words: {
       // 类废话词：禁止在类名中使用的冗余拼接词汇（统一小写）
@@ -211,8 +230,8 @@ class Detector {
         "data", "result", "output", "input", "param", "params", "parameter", "parameters",
         "value", "values", "item", "items",
         // 通用处理词汇（动词已经表达了处理，这些名词是冗余的）
-        "process", "handler", "processor", "manager", "controller", "service", "provider",
-        "factory", "builder", "adapter", "decorator", "proxy", "facade", "mediator",
+        "process", "processor", "provider",
+        "builder", "adapter", "decorator", "proxy", "facade", "mediator",
         "observer", "strategy", "command", "visitor", "iterator", "template",
         "flyweight", "memento", "interpreter",
         // 临时缓存词汇（动词已经表达了操作，这些名词是冗余的）
@@ -388,7 +407,7 @@ class Detector {
       Object.keys(config).forEach((key) => {
         if (merged_cfg[key] && typeof merged_cfg[key] === "object" && !Array.isArray(merged_cfg[key])) {
           // 如果是对象配置（如规则配置），则深度合并
-          merged_cfg[key] = { ...merged_cfg[key], ...config[key] };
+          merged_cfg[key] = this._deepMerge(merged_cfg[key], config[key]);
 
           // 处理字符串形式的正则表达式
           if (typeof merged_cfg[key].regex === "string") {
@@ -419,6 +438,37 @@ class Detector {
     this.config = merged_cfg;
     this._initRule();
   }
+
+  /**
+   * 深度合并两个对象
+   * @param {Object} target 目标对象
+   * @param {Object} source 源对象
+   * @returns {Object} 合并后的对象
+   * @private
+   */
+  _deepMerge(target, source) {
+    const result = { ...target };
+    
+    Object.keys(source).forEach((key) => {
+      const source_val = source[key];
+      const target_val = target[key];
+      
+      if (Array.isArray(source_val) && Array.isArray(target_val)) {
+        // 如果是数组，则合并数组（去重）
+        result[key] = [...new Set([...target_val, ...source_val])];
+      } else if (typeof source_val === 'object' && source_val !== null && 
+                 typeof target_val === 'object' && target_val !== null && 
+                 !Array.isArray(source_val) && !Array.isArray(target_val)) {
+        // 如果是对象，则递归深度合并
+        result[key] = this._deepMerge(target_val, source_val);
+      } else {
+        // 其他情况直接覆盖
+        result[key] = source_val;
+      }
+    });
+    
+    return result;
+  }
 }
 
 /**
@@ -482,6 +532,16 @@ Detector.prototype._checkName = function (rule_type, name) {
   const warnings = [];
   const recommendations = [];
 
+  // 首先检查是否为忽略词，如果是则跳过其他检测
+  if (this._isIgnoreWord(name, rule_type)) {
+    return {
+      valid: true,
+      errors: [],
+      warnings: [],
+      recommendations: []
+    };
+  }
+
   this._checkNameLength(name, config, errors);
   this._checkNameFormat(name, rule_type, config, errors);
   this._checkBadWords(name, config, errors);
@@ -1504,6 +1564,44 @@ Detector.prototype._isCompoundName = function (name) {
   return false;
 };
 
+/**
+ * 检查是否为忽略词
+ * @param {string} name - 名称
+ * @param {string} rule_type - 规则类型
+ * @returns {boolean} 是否为忽略词
+ * @private
+ */
+Detector.prototype._isIgnoreWord = function (name, rule_type) {
+  // 获取忽略词配置
+  const ignore_words_config = this.config.ignore_words;
+  if (!ignore_words_config) {
+    return false;
+  }
+
+  // 根据规则类型获取对应的忽略词列表
+  let ignore_list = [];
+  if (rule_type === "class-name") {
+    ignore_list = ignore_words_config.class || [];
+  } else if (rule_type === "method-name") {
+    ignore_list = ignore_words_config.method || [];
+  } else if (rule_type === "function-name") {
+    ignore_list = ignore_words_config.function || [];
+  }
+
+  // 检查名称是否完全匹配忽略词列表中的任何一个词
+  // 支持精确匹配和包含匹配（如果名称包含忽略词，则整个名称都被忽略）
+  // 支持大小写不敏感匹配
+  const name_lower = name.toLowerCase();
+  for (const ignore_word of ignore_list) {
+    const ignore_word_lower = ignore_word.toLowerCase();
+    if (name_lower === ignore_word_lower || name_lower.includes(ignore_word_lower)) {
+      return true;
+    }
+  }
+
+  return false;
+};
+
 /**
  * 检查推荐词并生成推荐建议
  * @param {string} name - 名称
@@ -1660,6 +1758,15 @@ const class_name_rule = {
           single_word: { type: "boolean" },
           single_word_len: { type: "number" },
           styles: { type: "array", items: { type: "string" } },
+          ignore_words: {
+            type: "object",
+            properties: {
+              class: { type: "array", items: { type: "string" } },
+              method: { type: "array", items: { type: "string" } },
+              function: { type: "array", items: { type: "string" } }
+            },
+            additionalProperties: false
+          }
         },
         additionalProperties: false,
       },
@@ -1708,6 +1815,15 @@ const function_name_rule = {
           single_word: { type: "boolean" },
           single_word_len: { type: "number" },
           styles: { type: "array", items: { type: "string" } },
+          ignore_words: {
+            type: "object",
+            properties: {
+              class: { type: "array", items: { type: "string" } },
+              method: { type: "array", items: { type: "string" } },
+              function: { type: "array", items: { type: "string" } }
+            },
+            additionalProperties: false
+          }
         },
         additionalProperties: false,
       },
@@ -1775,6 +1891,15 @@ const method_name_rule = {
           single_word: { type: "boolean" },
           single_word_len: { type: "number" },
           styles: { type: "array", items: { type: "string" } },
+          ignore_words: {
+            type: "object",
+            properties: {
+              class: { type: "array", items: { type: "string" } },
+              method: { type: "array", items: { type: "string" } },
+              function: { type: "array", items: { type: "string" } }
+            },
+            additionalProperties: false
+          }
         },
         additionalProperties: false,
       },

package/package.json

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