mm_eslint 1.2.8 → 1.2.9

package/detector.js

@@ -391,6 +391,14 @@ Detector.prototype._checkConstantName = function (constant_name, node, val_node)
       return null;
     }
 
+    // 检查是否为解构导入（从模块导入的变量）
+    var is_destructured_import = this._isDestructuredImport(node);
+    
+    // 如果是解构导入，则不进行常量检测
+    if (is_destructured_import) {
+      return null;
+    }
+
     // 检查是否为复杂类型（方法、函数、实例等）
     var is_complex_type = this._isComplexType(val_node);
 
@@ -692,6 +700,14 @@ Detector.prototype._checkPropertyName = function (
   parent_node,
 ) {
   try {
+    // 检查是否为解构导入中的属性
+    var is_destructured_import = this._isDestructuredImportProperty(node, parent_node);
+    
+    // 如果是解构导入中的属性，则不进行属性名检测
+    if (is_destructured_import) {
+      return null;
+    }
+
     // 获取属性类型
     var prop_type = this._getPropType(val_node, prop_name, parent_node);
     var rule_type = '';
@@ -906,6 +922,128 @@ Detector.prototype._isComplexType = function (val_node) {
   }
 };
 
+/**
+ * 检查是否为解构导入
+ * @param {object} node AST节点
+ * @returns {boolean} 是否为解构导入
+ */
+Detector.prototype._isDestructuredImport = function (node) {
+  try {
+    if (!node || !node.parent) {
+      return false;
+    }
+
+    // 检查是否为解构导入模式
+    var is_destructured = false;
+
+    // 情况1：节点是Property.key（解构赋值中的属性键）
+    if (node.parent.type === 'Property' && node.parent.key === node) {
+      var property = node.parent;
+      
+      // 检查Property的父节点是否为ObjectPattern
+      if (property.parent && property.parent.type === 'ObjectPattern') {
+        var object_pattern = property.parent;
+        
+        // 检查ObjectPattern的父节点是否为VariableDeclarator
+        if (object_pattern.parent && object_pattern.parent.type === 'VariableDeclarator') {
+          var declarator = object_pattern.parent;
+          
+          // 检查右侧是否为require调用或其他模块导入
+          if (declarator.init) {
+            var init_type = declarator.init.type;
+            
+            // 常见的模块导入方式
+            if (init_type === 'CallExpression' && 
+                declarator.init.callee && 
+                declarator.init.callee.name === 'require') {
+              is_destructured = true;
+            }
+            
+            // 如果是ImportDeclaration（ES6导入）
+            if (init_type === 'ImportExpression') {
+              is_destructured = true;
+            }
+          }
+        }
+      }
+    }
+    
+    // 情况2：节点是VariableDeclarator（简单变量声明）
+    else if (node.parent.type === 'VariableDeclarator') {
+      var declarator = node.parent;
+      
+      // 检查是否为解构模式（ObjectPattern或ArrayPattern）
+      if (declarator.id && declarator.id.type === 'ObjectPattern') {
+        // 检查右侧是否为require调用或其他模块导入
+        if (declarator.init) {
+          var init_type = declarator.init.type;
+          
+          // 常见的模块导入方式
+          if (init_type === 'CallExpression' && 
+              declarator.init.callee && 
+              declarator.init.callee.name === 'require') {
+            is_destructured = true;
+          }
+          
+          // 如果是ImportDeclaration（ES6导入）
+          if (init_type === 'ImportExpression') {
+            is_destructured = true;
+          }
+        }
+      }
+    }
+
+    return is_destructured;
+  } catch (error) {
+    console.error('检查是否为解构导入时出错:', error);
+    return false;
+  }
+};
+
+/**
+ * 检查是否为解构导入中的属性
+ * @param {object} node 属性节点
+ * @param {object} parent_node 父节点
+ * @returns {boolean} 是否为解构导入中的属性
+ */
+Detector.prototype._isDestructuredImportProperty = function (node, parent_node) {
+  try {
+    if (!node || !parent_node) {
+      return false;
+    }
+
+    // 检查父节点是否为ObjectPattern（解构模式）
+    if (parent_node.type === 'ObjectPattern') {
+      // 检查父节点的父节点是否为VariableDeclarator
+      if (parent_node.parent && parent_node.parent.type === 'VariableDeclarator') {
+        var declarator = parent_node.parent;
+        
+        // 检查右侧是否为require调用或其他模块导入
+        if (declarator.init) {
+          var init_type = declarator.init.type;
+          
+          // 常见的模块导入方式
+          if (init_type === 'CallExpression' && 
+              declarator.init.callee && 
+              declarator.init.callee.name === 'require') {
+            return true;
+          }
+          
+          // 如果是ImportDeclaration（ES6导入）
+          if (init_type === 'ImportExpression') {
+            return true;
+          }
+        }
+      }
+    }
+
+    return false;
+  } catch (error) {
+    console.error('检查是否为解构导入中的属性时出错:', error);
+    return false;
+  }
+};
+
 /**
  * 检查常量名是否符合规范
  * @param {string} constant_name 常量名
@@ -995,4 +1133,82 @@ Detector.prototype._generateRecommendedName = function (original_name, long_word
   }
 };
 
+/**
+ * 检测解构赋值中的常量名
+ * @param {string} constant_name 常量名
+ * @param {object} node AST节点
+ * @returns {object|null} 错误信息或null
+ */
+Detector.prototype._checkConstantNameForDestructuring = function (constant_name, 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;
+    }
+
+    // 检查命名风格
+    var style_err = this._validate_naming_style(constant_name, rule.styles, 'constant-name');
+    if (style_err) {
+      return {
+        node: node,
+        message: style_err,
+      };
+    }
+
+    // 检查并推荐更合适的词汇
+    var rec_err = this._checkAndRecommend(constant_name, 'constant-name');
+    if (rec_err) {
+      return {
+        node: node,
+        message: rec_err,
+      };
+    }
+
+    // 检查长度
+    var len_err = this._checkNameLength(constant_name, rule.min, rule.max, 'constant-name');
+    if (len_err) {
+      return {
+        node: node,
+        message: len_err,
+      };
+    }
+
+    // 检查单词长度
+    var word_err = this._checkWordLength(constant_name, rule.single_word_len, 'constant-name');
+    if (word_err) {
+      return {
+        node: node,
+        message: word_err,
+      };
+    }
+
+    // 检查禁止词汇
+    var forbid_err = this._checkForbiddenWords(constant_name, 'constant-name');
+    if (forbid_err) {
+      return {
+        node: node,
+        message: forbid_err,
+      };
+    }
+
+    return null;
+  } catch (error) {
+    console.error('检测解构赋值常量名时出错:', error);
+    return null;
+  }
+};
+
 module.exports = { Detector };

package/index.js

@@ -121,19 +121,52 @@ function createNamingRules() {
       },
       create: function (context) {
         return {
-          VariableDeclarator: function (node) {
+          VariableDeclaration: function (node) {
             // 排除const声明，只检测let和var声明的变量
-            if (node.parent && node.parent.kind !== 'const') {
-              if (node.id && node.id.name) {
-                var variable_name = node.id.name;
-                var err = detector._checkVariableName(variable_name, node);
-                if (err) {
-                  context.report({
-                    node: err.node,
-                    message: err.message,
+            if (node.kind !== 'const') {
+              node.declarations.forEach(function(decl) {
+                // 处理简单变量声明
+                if (decl.id && decl.id.type === 'Identifier') {
+                  var variable_name = decl.id.name;
+                  var err = detector._checkVariableName(variable_name, decl);
+                  if (err) {
+                    context.report({
+                      node: decl.id,
+                      message: err.message,
+                    });
+                  }
+                }
+                // 处理解构赋值 - ObjectPattern
+                else if (decl.id && decl.id.type === 'ObjectPattern') {
+                  decl.id.properties.forEach(function(property) {
+                    if (property.key && property.key.type === 'Identifier') {
+                      var variable_name = property.key.name;
+                      var err = detector._checkVariableName(variable_name, decl);
+                      if (err) {
+                        context.report({
+                          node: property.key,
+                          message: err.message,
+                        });
+                      }
+                    }
                   });
                 }
-              }
+                // 处理解构赋值 - ArrayPattern
+                else if (decl.id && decl.id.type === 'ArrayPattern') {
+                  decl.id.elements.forEach(function(element, index) {
+                    if (element && element.type === 'Identifier') {
+                      var variable_name = element.name;
+                      var err = detector._checkVariableName(variable_name, decl);
+                      if (err) {
+                        context.report({
+                          node: element,
+                          message: err.message,
+                        });
+                      }
+                    }
+                  });
+                }
+              });
             }
           },
         };
@@ -219,18 +252,53 @@ function createNamingRules() {
       },
       create: function (context) {
         return {
-          VariableDeclarator: function (node) {
-            if (node.parent && node.parent.kind === 'const') {
-              if (node.id && node.id.name) {
-                var constant_name = node.id.name;
-                var err = detector._checkConstantName(constant_name, node, node.init);
-                if (err) {
-                  context.report({
-                    node: err.node,
-                    message: err.message,
+          VariableDeclaration: function (node) {
+            if (node.kind === 'const') {
+              node.declarations.forEach(function(decl) {
+                // 处理简单变量声明
+                if (decl.id && decl.id.type === 'Identifier') {
+                  var constant_name = decl.id.name;
+                  var err = detector._checkConstantName(constant_name, decl, decl.init);
+                  if (err) {
+                    context.report({
+                      node: decl.id,
+                      message: err.message,
+                    });
+                  }
+                }
+                // 处理解构赋值 - ObjectPattern
+                else if (decl.id && decl.id.type === 'ObjectPattern') {
+                  decl.id.properties.forEach(function(property) {
+                    if (property.key && property.key.type === 'Identifier') {
+                      var constant_name = property.key.name;
+                      // 对于解构赋值，使用专门的检测方法
+                      var err = detector._checkConstantNameForDestructuring(constant_name, property.key);
+                      if (err) {
+                        context.report({
+                          node: property.key,
+                          message: err.message,
+                        });
+                      }
+                    }
                   });
                 }
-              }
+                // 处理解构赋值 - ArrayPattern
+                else if (decl.id && decl.id.type === 'ArrayPattern') {
+                  decl.id.elements.forEach(function(element, index) {
+                    if (element && element.type === 'Identifier') {
+                      var constant_name = element.name;
+                      // 对于解构赋值，使用专门的检测方法
+                      var err = detector._checkConstantNameForDestructuring(constant_name, element);
+                      if (err) {
+                        context.report({
+                          node: element,
+                          message: err.message,
+                        });
+                      }
+                    }
+                  });
+                }
+              });
             }
           },
         };

package/package.json

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