mm_eslint 1.6.0 → 1.6.2

package/lib/config.js

@@ -118,7 +118,6 @@ Config.prototype.getForbiddenWords = function (name_type) {
       'parameters',
       'item',
       'items',
-      'process',
       'processor',
       'provider',
       'builder',

package/lib/detector/function_name.js

@@ -262,6 +262,11 @@ FunctionName.prototype.CallExpression = function (node) {
       return undefined;
     }
     
+    // 检查是否为导入的函数或第三方库函数
+    if (this._isExternalFunction(node, name)) {
+      return undefined;
+    }
+    
     let original_type = 'use-function';
     let error = this.check(node, name, original_type);
     this.report(node, error, original_type);
@@ -281,6 +286,19 @@ FunctionName.prototype.CallExpression = function (node) {
         return undefined;
       }
       
+      // 检查是否为 this. 开头的函数调用，如果是则直接检测（通常是自定义函数）
+      if (callee.object && callee.object.type === 'ThisExpression') {
+        let original_type = 'use-function';
+        let error = this.check(callee.property, name, original_type);
+        this.report(callee.property, error, original_type);
+        return error;
+      }
+      
+      // 检查是否为导入的函数或第三方库函数
+      if (this._isExternalFunction(node, name)) {
+        return undefined;
+      }
+      
       let original_type = 'use-function';
       let error = this.check(callee.property, name, original_type);
       this.report(callee.property, error, original_type);
@@ -366,4 +384,125 @@ FunctionName.prototype.ExportNamedDeclaration = function (node) {
   }
 }
 
+/**
+ * 检查函数是否为外部函数（不在当前作用域内定义的函数）
+ * @param {Object} node - 调用表达式节点
+ * @param {string} name - 函数名
+ * @returns {boolean} - 是否为外部函数
+ */
+FunctionName.prototype._isExternalFunction = function (node, name) {
+  if (!name || !node) {
+    return false;
+  }
+
+  // 如果函数在当前作用域内有定义，则不是外部函数
+  if (this._isFunctionInScope(name, node)) {
+    return false;
+  }
+
+  // 检查是否为导入的函数（通过 import 或 require）
+  if (this._isImportedFunction(name, node)) {
+    return true;
+  }
+
+  // 检查是否为全局对象上的函数（如 console.log, Math.max 等）
+  if (this._isGlobalObjectFunction(name, node)) {
+    return true;
+  }
+
+  // 默认情况下，如果函数不在当前作用域内定义，则认为是外部函数
+  return true;
+}
+
+/**
+ * 检查函数是否为导入的函数
+ * @param {string} name - 函数名
+ * @param {Object} node - 当前节点
+ * @returns {boolean} - 是否为导入的函数
+ */
+FunctionName.prototype._isImportedFunction = function (name, node) {
+  if (!name || !node) {
+    return false;
+  }
+
+  // 获取AST根节点
+  let program_node = this._getProgramNode(node);
+  if (!program_node || !program_node.body) {
+    return false;
+  }
+
+  // 遍历同级节点查找导入声明
+  for (let i = 0; i < program_node.body.length; i++) {
+    let sibling_node = program_node.body[i];
+
+    // 检查ES6导入声明
+    if (sibling_node.type === 'ImportDeclaration') {
+      if (sibling_node.specifiers && sibling_node.specifiers.length > 0) {
+        for (let j = 0; j < sibling_node.specifiers.length; j++) {
+          let specifier = sibling_node.specifiers[j];
+          
+          // 检查导入的标识符名称
+          if (specifier.local && specifier.local.type === 'Identifier' && specifier.local.name === name) {
+            return true;
+          }
+        }
+      }
+    }
+
+    // 检查CommonJS require导入
+    if (sibling_node.type === 'VariableDeclaration') {
+      for (let j = 0; j < sibling_node.declarations.length; j++) {
+        let decl = sibling_node.declarations[j];
+        if (decl.id && decl.id.type === 'Identifier' && decl.id.name === name) {
+          // 检查是否为require调用
+          if (decl.init && decl.init.type === 'CallExpression' && 
+              decl.init.callee && decl.init.callee.type === 'Identifier' && 
+              decl.init.callee.name === 'require') {
+            return true;
+          }
+        }
+      }
+    }
+  }
+
+  return false;
+}
+
+/**
+ * 检查函数是否为全局对象上的函数
+ * @param {string} name - 函数名
+ * @param {Object} node - 当前节点
+ * @returns {boolean} - 是否为全局对象函数
+ */
+FunctionName.prototype._isGlobalObjectFunction = function (name, node) {
+  if (!name) {
+    return false;
+  }
+
+  // 常见的全局对象函数列表
+  const global_object_functions = [
+    // console 对象
+    'log', 'info', 'warn', 'error', 'debug', 'table', 'time', 'timeEnd',
+    // Math 对象
+    'abs', 'ceil', 'floor', 'round', 'max', 'min', 'pow', 'sqrt', 'random',
+    // JSON 对象
+    'parse', 'stringify',
+    // Object 对象
+    'keys', 'values', 'entries', 'assign', 'create', 'freeze', 'seal',
+    // Array 对象
+    'isArray', 'from', 'of',
+    // String 对象
+    'fromCharCode', 'fromCodePoint',
+    // Number 对象
+    'isFinite', 'isInteger', 'isNaN', 'isSafeInteger', 'parseFloat', 'parseInt',
+    // Date 对象
+    'now', 'parse', 'UTC',
+    // RegExp 对象
+    'test', 'exec'
+  ];
+
+  // 检查是否为全局对象函数
+  return global_object_functions.includes(name);
+}
+
 module.exports = { FunctionName }

package/lib/detector/name.js

@@ -197,6 +197,69 @@ Name.prototype._isClassInScope = function (name, node) {
   return false;
 }
 
+/**
+ * 检查类声明中是否包含指定名称的方法
+ * @param {Object} class_node - 类声明节点
+ * @param {string} name - 方法名
+ * @returns {boolean} - 是否包含该方法
+ */
+Name.prototype._isFunctionInClass = function (class_node, name) {
+  if (!class_node || !class_node.body || !class_node.body.body) {
+    return false;
+  }
+
+  // 遍历类体中的方法定义
+  for (let i = 0; i < class_node.body.body.length; i++) {
+    let method_node = class_node.body.body[i];
+
+    // 检查方法定义（MethodDefinition）
+    if (method_node.type === 'MethodDefinition') {
+      if (method_node.key && method_node.key.type === 'Identifier' && method_node.key.name === name) {
+        return true;
+      }
+    }
+
+    // 检查类属性中的函数赋值（PropertyDefinition）
+    if (method_node.type === 'PropertyDefinition') {
+      if (method_node.key && method_node.key.type === 'Identifier' && method_node.key.name === name) {
+        // 检查属性值是否为函数表达式
+        if (method_node.value && (method_node.value.type === 'FunctionExpression' || method_node.value.type === 'ArrowFunctionExpression')) {
+          return true;
+        }
+      }
+    }
+
+    // 检查构造函数中的方法赋值
+    if (method_node.type === 'MethodDefinition' && method_node.kind === 'constructor') {
+      if (method_node.value && method_node.value.body && method_node.value.body.body) {
+        // 遍历构造函数体中的语句
+        for (let j = 0; j < method_node.value.body.body.length; j++) {
+          let statement = method_node.value.body.body[j];
+          
+          // 检查 this.property = function() {} 形式的赋值
+          if (statement.type === 'ExpressionStatement' && statement.expression && statement.expression.type === 'AssignmentExpression') {
+            let expr = statement.expression;
+            
+            // 检查左边是否为 this.propertyName 形式
+            if (expr.left && expr.left.type === 'MemberExpression' && 
+                expr.left.object && expr.left.object.type === 'ThisExpression' &&
+                expr.left.property && expr.left.property.type === 'Identifier' &&
+                expr.left.property.name === name) {
+              
+              // 检查右边是否为函数表达式
+              if (expr.right && (expr.right.type === 'FunctionExpression' || expr.right.type === 'ArrowFunctionExpression')) {
+                return true;
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+
+  return false;
+}
+
 /**
  * 检查标识符是否在作用域内定义为函数
  * @param {string} name - 标识符名称
@@ -242,6 +305,13 @@ Name.prototype._isFunctionInScope = function (name, node) {
         }
       }
     }
+
+    // 查找类声明中的方法定义
+    if (sibling_node.type === 'ClassDeclaration') {
+      if (this._isFunctionInClass(sibling_node, name)) {
+        return true;
+      }
+    }
   }
 
   return false;

package/lib/validator.js

@@ -84,7 +84,9 @@ Validator.prototype.check = function (name, words, rule) {
     }
 
     // 检查每个单词的长度, 警告级。
-    var word_error = this._validateWordLength(words, rule.single_word_len);
+    // 长度检测前过滤掉忽略词
+    var ws = this._filterIgnoreWords(words, rule.ignore_words);
+    var word_error = this._validateWordLength(ws, rule.single_word_len);
     if (word_error) {
       return word_error;
     }
@@ -96,6 +98,29 @@ Validator.prototype.check = function (name, words, rule) {
   }
 }
 
+/**
+ * 过滤掉忽略词
+ * @param {array} words 单词数组
+ * @param {array} ignore_words 忽略词数组
+ * @returns {array} 过滤后的单词数组
+ */
+Validator.prototype._filterIgnoreWords = function (words, ignore_words) {
+  if (!words || words.length === 0) {
+    return [];
+  }
+  
+  if (!ignore_words || ignore_words.length === 0) {
+    return words;
+  }
+  
+  // 过滤掉忽略词
+  var ws = words.filter((word) => {
+    return !this._isIgnoreWord(word, ignore_words);
+  });
+  
+  return ws;
+}
+
 /**
  * 判断名称是否为忽略词
  * @param {string} name 名称

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mm_eslint",
-  "version": "1.6.0",
+  "version": "1.6.2",
   "description": "ESLint plugin for personal naming conventions - supports PascalCase, camelCase, snake_case, and UPPER_SNAKE_CASE naming rules with intelligent recommendations",
   "main": "index.js",
   "keywords": [