mm_eslint 1.4.0 → 1.4.1

package/detector.js

@@ -381,20 +381,10 @@ Detector.prototype._checkParamName = function (param_name, node) {
  */
 Detector.prototype._checkConstantName = function (constant_name, node, val_node) {
   try {
-    var rule = this.config.getRule('constant-name');
-    if (!rule) {
-      return null;
-    }
-
-    // 检查是否为忽略词
-    if (this._isIgnoredWord(constant_name, 'constant-name')) {
-      return null;
-    }
-
     // 检查是否为解构导入（从模块导入的变量）
     var is_destructured_import = this._isDestructuredImport(node);
     
-    // 如果是解构导入，则不进行常量检测
+    // 如果是解构导入，则不进行命名检测
     if (is_destructured_import) {
       return null;
     }
@@ -410,24 +400,49 @@ Detector.prototype._checkConstantName = function (constant_name, node, val_node)
       };
     }
 
-    // 检查是否为复杂类型（方法、函数、实例等）
-    var is_complex_type = this._isComplexType(val_node);
+    // 根据值类型确定应该应用的命名规则
+    var rule_type = 'constant-name'; // 默认使用常量命名规则
+    var allowed_styles = [];
 
-    // 如果是复杂类型，则不进行常量检测
-    if (is_complex_type) {
+    // 检查是否为函数表达式或箭头函数
+    if (val_node && (val_node.type === 'FunctionExpression' || val_node.type === 'ArrowFunctionExpression')) {
+      rule_type = 'function-name';
+    }
+    // 检查是否为类表达式
+    else if (val_node && val_node.type === 'ClassExpression') {
+      rule_type = 'class-name';
+    }
+    // 检查是否为类实例（new表达式）
+    else if (val_node && val_node.type === 'NewExpression') {
+      rule_type = 'function-name'; // 类实例使用函数命名规则（camelCase）
+    }
+    // 检查是否为基础值类型
+    else if (val_node && this._isBaseValue(val_node)) {
+      rule_type = 'constant-name';
+    }
+    // 检查是否为其他复杂类型（函数调用、变量引用等）
+    else if (val_node && this._isComplexType(val_node)) {
+      // 其他复杂类型不进行命名检测
+      return null;
+    }
+    // 其他情况不进行命名检测
+    else {
       return null;
     }
 
-    // 检查是否为基础值类型
-    var is_base_value = this._isBaseValue(val_node);
+    // 获取对应的命名规则
+    var rule = this.config.getRule(rule_type);
+    if (!rule) {
+      return null;
+    }
 
-    // 如果不是基础值也不是复杂类型（可能是其他类型），则不进行常量检测
-    if (!is_base_value) {
+    // 检查是否为忽略词
+    if (this._isIgnoredWord(constant_name, rule_type)) {
       return null;
     }
 
     // 检查命名风格
-    var style_err = this._validate_naming_style(constant_name, rule.styles, 'constant-name');
+    var style_err = this._validate_naming_style(constant_name, rule.styles, rule_type);
     if (style_err) {
       return {
         node: node,
@@ -711,25 +726,57 @@ Detector.prototype._splitNameIntoWords = function (name) {
  */
 Detector.prototype._isThirdPartyConfigProperty = function (node, parent_node) {
   try {
+    // 处理新的父节点信息结构（包含node和parent属性）
+    var actual_parent_node = parent_node;
+    if (parent_node && typeof parent_node === 'object' && parent_node.node) {
+      actual_parent_node = parent_node.node;
+    }
+    
     // 检查当前节点是否为对象字面量的属性
-    if (!parent_node || parent_node.type !== 'ObjectExpression') {
+    if (!actual_parent_node || actual_parent_node.type !== 'ObjectExpression') {
       return false;
     }
 
-    // 检查对象字面量是否作为方法调用的参数
-    var grandparent = parent_node.parent;
-    if (!grandparent || grandparent.type !== 'CallExpression') {
+    // 递归查找调用表达式（处理嵌套对象的情况）
+    var findCallExpression = function(current_node) {
+      if (!current_node) {
+        return null;
+      }
+      
+      if (current_node.type === 'CallExpression') {
+        return current_node;
+      }
+      
+      // 继续向上查找
+      return findCallExpression(current_node.parent);
+    };
+
+    // 优先使用新的父节点信息结构中的parent属性
+    var grandparent = parent_node && typeof parent_node === 'object' && parent_node.parent 
+      ? parent_node.parent 
+      : actual_parent_node.parent;
+      
+    // 查找调用表达式
+    var call_expression = findCallExpression(grandparent);
+    if (!call_expression) {
       return false;
     }
 
     // 检查方法调用是否来自外部模块（非当前文件定义的函数）
-    var callee = grandparent.callee;
+    var callee = call_expression.callee;
     if (!callee) {
       return false;
     }
 
     // 如果是成员表达式（如 chokidar.watch），则认为是第三方库调用
     if (callee.type === 'MemberExpression') {
+      // 检查成员表达式的对象是否为模块导入变量
+      var is_module_import = this._isModuleImportVariable(callee.object);
+      if (is_module_import) {
+        return true;
+      }
+      
+      // 对于其他成员表达式，也认为是第三方库调用（保守策略）
       return true;
     }
 
@@ -746,6 +793,12 @@ Detector.prototype._isThirdPartyConfigProperty = function (node, parent_node) {
         return true;
       }
       
+      // 检查标识符是否为模块导入变量
+      var is_module_import = this._isModuleImportVariable(callee);
+      if (is_module_import) {
+        return true;
+      }
+      
       // 对于其他标识符，暂时不认为是第三方库调用（避免误判）
       return false;
     }
@@ -1056,6 +1109,12 @@ Detector.prototype._shouldUseLetInsteadOfConst = function (node, val_node) {
       return false;
     }
 
+    // 检查是否为模块导入（需要排除的情况）
+    var is_module_import = this._isModuleImport(node, val_node);
+    if (is_module_import) {
+      return false;
+    }
+
     // 检查是否为解构赋值
     var is_destructuring = false;
     if (node.parent && node.parent.type === 'VariableDeclarator') {
@@ -1065,11 +1124,30 @@ Detector.prototype._shouldUseLetInsteadOfConst = function (node, val_node) {
       }
     }
 
-    // 检查右侧是否为复杂类型（类实例、函数、对象等）
+    // 应该使用let的情况：
+    // 1. 函数调用（CallExpression）- 返回值可能变化
+    // 2. 变量引用（Identifier）- 可能被重新赋值
+    // 3. 条件表达式等可能产生不同结果的情况
+    
+    var should_use_let = false;
+    
+    // 检查是否为函数调用
+    if (val_node.type === 'CallExpression') {
+      should_use_let = true;
+    }
+    
+    // 检查是否为变量引用
+    if (val_node.type === 'Identifier') {
+      should_use_let = true;
+    }
+    
+    // 检查是否为解构赋值且右侧是复杂类型
     var is_complex_type = this._isComplexType(val_node);
-
-    // 如果是解构赋值且右侧是复杂类型，建议使用let
-    return is_destructuring && is_complex_type;
+    if (is_destructuring && is_complex_type) {
+      should_use_let = true;
+    }
+    
+    return should_use_let;
   } catch (error) {
     console.error('检查是否应该使用let时出错:', error);
     return false;
@@ -1113,6 +1191,91 @@ Detector.prototype._isComplexType = function (val_node) {
   }
 };
 
+/**
+ * 检查是否为模块导入（需要排除const检测的情况）
+ * @param {object} node 变量声明节点
+ * @param {object} val_node 值节点
+ * @returns {boolean} 是否为模块导入
+ */
+Detector.prototype._isModuleImport = function (node, val_node) {
+  try {
+    if (!node || !val_node) {
+      return false;
+    }
+
+    // 情况1：const xxx = require('module') - 直接模块导入
+    if (val_node.type === 'CallExpression' && val_node.callee) {
+      // 检查是否为require调用
+      if (val_node.callee.type === 'Identifier' && val_node.callee.name === 'require') {
+        return true;
+      }
+      
+      // 检查是否为import()动态导入
+      if (val_node.callee.type === 'Import') {
+        return true;
+      }
+    }
+
+    // 情况2：const {xxx} = require('module') - 解构模块导入
+    if (node.parent && node.parent.type === 'VariableDeclarator') {
+      var declarator = node.parent;
+      
+      // 检查是否为解构赋值
+      if (declarator.id && declarator.id.type === 'ObjectPattern') {
+        // 检查右侧是否为require调用
+        if (val_node.type === 'CallExpression' && val_node.callee) {
+          if (val_node.callee.type === 'Identifier' && val_node.callee.name === 'require') {
+            return true;
+          }
+        }
+      }
+    }
+
+    return false;
+  } catch (error) {
+    console.error('检查是否为模块导入时出错:', error);
+    return false;
+  }
+};
+
+/**
+ * 检查标识符是否为模块导入变量
+ * @param {object} node AST节点（Identifier类型）
+ * @returns {boolean} 是否为模块导入变量
+ */
+Detector.prototype._isModuleImportVariable = function (node) {
+  try {
+    if (!node || node.type !== 'Identifier') {
+      return false;
+    }
+
+    // 检查变量声明是否为模块导入
+    if (node.parent && node.parent.parent) {
+      var variable_declaration = node.parent.parent;
+      
+      // 检查是否为const声明
+      if (variable_declaration.type === 'VariableDeclaration' && variable_declaration.kind === 'const') {
+        // 检查声明中是否有require调用
+        var declarators = variable_declaration.declarations;
+        for (var i = 0; i < declarators.length; i++) {
+          var declarator = declarators[i];
+          if (declarator.init && declarator.init.type === 'CallExpression') {
+            var init_call = declarator.init;
+            if (init_call.callee && init_call.callee.type === 'Identifier' && init_call.callee.name === 'require') {
+              return true;
+            }
+          }
+        }
+      }
+    }
+
+    return false;
+  } catch (error) {
+    console.error('检查是否为模块导入变量时出错:', error);
+    return false;
+  }
+};
+
 /**
  * 检查是否为解构导入
  * @param {object} node AST节点
@@ -1199,15 +1362,25 @@ Detector.prototype._isDestructuredImport = function (node) {
  */
 Detector.prototype._isDestructuredImportProperty = function (node, parent_node) {
   try {
-    if (!node || !parent_node) {
+    // 处理新的父节点信息结构（包含node和parent属性）
+    var actual_parent_node = parent_node;
+    if (parent_node && typeof parent_node === 'object' && parent_node.node) {
+      actual_parent_node = parent_node.node;
+    }
+    
+    if (!node || !actual_parent_node) {
       return false;
     }
 
     // 检查父节点是否为ObjectPattern（解构模式）
-    if (parent_node.type === 'ObjectPattern') {
+    if (actual_parent_node.type === 'ObjectPattern') {
       // 检查父节点的父节点是否为VariableDeclarator
-      if (parent_node.parent && parent_node.parent.type === 'VariableDeclarator') {
-        var declarator = parent_node.parent;
+      var actual_parent_parent = parent_node && typeof parent_node === 'object' && parent_node.parent 
+        ? parent_node.parent 
+        : actual_parent_node.parent;
+        
+      if (actual_parent_parent && actual_parent_parent.type === 'VariableDeclarator') {
+        var declarator = actual_parent_parent;
         
         // 检查右侧是否为require调用或其他模块导入
         if (declarator.init) {
@@ -1235,6 +1408,83 @@ Detector.prototype._isDestructuredImportProperty = function (node, parent_node)
   }
 };
 
+/**
+ * 检查是否为函数赋值（函数表达式或箭头函数）
+ * @param {object} node AST节点
+ * @returns {boolean} 是否为函数赋值
+ */
+Detector.prototype._isFunctionAssignment = function (node) {
+  try {
+    if (!node) {
+      return false;
+    }
+
+    // 检查节点是否为解构赋值中的属性
+    if (node.type === 'Property' && node.key === node) {
+      // 检查父节点是否为ObjectPattern
+      if (node.parent && node.parent.type === 'ObjectPattern') {
+        // 检查父节点的父节点是否为VariableDeclarator
+        if (node.parent.parent && node.parent.parent.type === 'VariableDeclarator') {
+          var declarator = node.parent.parent;
+          
+          // 检查右侧是否为函数表达式或箭头函数
+          if (declarator.init) {
+            var init_type = declarator.init.type;
+            
+            // 函数表达式
+            if (init_type === 'FunctionExpression') {
+              return true;
+            }
+            
+            // 箭头函数
+            if (init_type === 'ArrowFunctionExpression') {
+              return true;
+            }
+            
+            // 函数调用（可能返回函数）
+            if (init_type === 'CallExpression') {
+              return true;
+            }
+          }
+        }
+      }
+    }
+
+    // 检查节点是否为解构赋值中的数组元素
+    if (node.type === 'Identifier' && node.parent && node.parent.type === 'ArrayPattern') {
+      // 检查父节点的父节点是否为VariableDeclarator
+      if (node.parent.parent && node.parent.parent.type === 'VariableDeclarator') {
+        var declarator = node.parent.parent;
+        
+        // 检查右侧是否为函数表达式或箭头函数
+        if (declarator.init) {
+          var init_type = declarator.init.type;
+          
+          // 函数表达式
+          if (init_type === 'FunctionExpression') {
+            return true;
+          }
+          
+          // 箭头函数
+          if (init_type === 'ArrowFunctionExpression') {
+            return true;
+          }
+          
+          // 函数调用（可能返回函数）
+          if (init_type === 'CallExpression') {
+            return true;
+          }
+        }
+      }
+    }
+
+    return false;
+  } catch (error) {
+    console.error('检查是否为函数赋值时出错:', error);
+    return false;
+  }
+};
+
 /**
  * 检查常量名是否符合规范
  * @param {string} constant_name 常量名
@@ -1350,12 +1600,25 @@ Detector.prototype._checkConstantNameForDestructuring = function (constant_name,
       return null;
     }
 
-    // 对于解构赋值，直接提示使用let而不是const
-    // 因为解构赋值通常不是真正的常量
-    return {
-      node: node,
-      message: `变量'${constant_name}'应该使用let而不是const声明，因为它不是真正的常量`
-    };
+    // 检查是否为函数赋值（函数表达式或箭头函数）
+    var is_function_assignment = this._isFunctionAssignment(node);
+    
+    // 如果是函数赋值，允许camelCase命名风格
+    var allowed_styles = [];
+    if (is_function_assignment) {
+      allowed_styles = ['camelCase', 'UPPER_SNAKE_CASE'];
+    } else {
+      allowed_styles = rule.styles;
+    }
+
+    // 检查命名风格
+    var style_err = this._validate_naming_style(constant_name, allowed_styles, 'constant-name');
+    if (style_err) {
+      return {
+        node: node,
+        message: style_err,
+      };
+    }
 
     // 检查并推荐更合适的词汇
     var rec_err = this._checkAndRecommend(constant_name, 'constant-name');

package/index.js

@@ -331,11 +331,17 @@ function createNamingRules() {
               return;
             }
             
+            // 传递祖父节点信息，用于第三方库排除检测
+            var parent_info = {
+              node: node.parent,
+              parent: node.parent ? node.parent.parent : null
+            };
+            
             var err = detector._checkPropertyName(
               prop_name,
               node,
               node.value,
-              node.parent,
+              parent_info,
             );
             
             if (err) {

package/package.json

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