mm_eslint 1.4.3 → 1.4.5

package/index.js

@@ -1,90 +1,29 @@
 /**
  * ESLint命名规范检测插件
- * 版本: 1.1.0 - 支持跳过null值和未赋值属性检测
+ * 版本: 2.0.0 - 模块化重构版，职责分离
  */
-
-const { Config } = require('./config');
-const { Detector } = require('./detector');
+const { Handler } = require('./handler');
 
 /**
- * 创建ESLint规则配置
- * @returns {object} ESLint规则配置对象
+ * 规则定义类
+ * 负责定义ESLint规则配置
  */
-function createNamingRules() {
-  var config = new Config({});
-  var detector = new Detector(config);
-
+class Rules {
   /**
-   * 检查节点是否为参数名或参数引用
-   * @param {object} node AST节点
-   * @returns {boolean} 是否为参数名或参数引用
+   * 构造函数
    */
-  function _isParameterName(node) {
-    if (!node || !node.parent) {
-      return false;
-    }
-    
-    // 检查是否为函数参数声明
-    var parent = node.parent;
-    if (parent.type === 'FunctionDeclaration' || 
-        parent.type === 'FunctionExpression' || 
-        parent.type === 'ArrowFunctionExpression') {
-      if (parent.params && Array.isArray(parent.params)) {
-        for (var i = 0; i < parent.params.length; i++) {
-          if (parent.params[i] === node) {
-            return true;
-          }
-        }
-      }
-    }
-    
-    // 检查是否为变量声明中的参数
-    if (parent.type === 'VariableDeclarator' && parent.id === node) {
-      var grand_parent = parent.parent;
-      if (grand_parent && grand_parent.type === 'VariableDeclaration') {
-        // 检查是否为函数参数
-        var great_grand_parent = grand_parent.parent;
-        if (great_grand_parent && 
-            (great_grand_parent.type === 'FunctionDeclaration' || 
-             great_grand_parent.type === 'FunctionExpression' || 
-             great_grand_parent.type === 'ArrowFunctionExpression')) {
-          return true;
-        }
-      }
-    }
-    
-    // 检查是否为参数引用（在函数调用中）
-    if (node.type === 'Identifier') {
-      // 检查是否在函数调用表达式中
-      if (parent.type === 'CallExpression' && parent.callee === node) {
-        // 检查是否在函数作用域内
-        var current_scope = parent;
-        while (current_scope) {
-          // 检查当前作用域是否为函数
-          if (current_scope.type === 'FunctionDeclaration' || 
-              current_scope.type === 'FunctionExpression' || 
-              current_scope.type === 'ArrowFunctionExpression') {
-            // 检查函数参数中是否有同名参数
-            if (current_scope.params && Array.isArray(current_scope.params)) {
-              for (var i = 0; i < current_scope.params.length; i++) {
-                var param = current_scope.params[i];
-                if (param.type === 'Identifier' && param.name === node.name) {
-                  return true;
-                }
-              }
-            }
-            break;
-          }
-          current_scope = current_scope.parent;
-        }
-      }
-    }
-    
-    return false;
+  constructor() {
+    this.handler = new Handler();
   }
 
-  return {
-    'class-name': {
+  /**
+   * 创建类名规则
+   * @returns {object} 类名规则配置
+   */
+  createClassNameRule() {
+    var handler = this.handler;
+    
+    return {
       meta: {
         type: 'suggestion',
         docs: {
@@ -98,37 +37,49 @@ function createNamingRules() {
       create: function (context) {
         return {
           ClassDeclaration: function (node) {
-            var class_name = node.id.name;
-            var err = detector._checkClassName(class_name, node);
-            if (err) {
-              // 获取修复建议
-              var fix_suggestion = detector._getFixSuggestion(class_name, 'class-name', err.message);
-              
-              var report_obj = {
-                node: err.node,
-                message: err.message,
-              };
-              
-              // 如果有修复建议，添加修复功能
-              if (fix_suggestion) {
-                report_obj.fix = function(fixer) {
-                  return fixer.replaceText(node.id, fix_suggestion.fixed_name);
-                };
-                report_obj.message += '，建议使用: ' + fix_suggestion.fixed_name;
-              }
-              
-              context.report(report_obj);
-            }
+            handler.handleClassDeclaration(context, node, node, 'class');
+          },
+          VariableDeclaration: function (node) {
+            handler.handleVariableDeclaration(context, node, node, 'class');
+          },
+          Property: function (node) {
+            handler.handleProperty(context, node, node, 'class');
+          },
+          AssignmentExpression: function (node) {
+            handler.handleAssignmentExpression(context, node, node, 'class');
           },
+          ExportDefaultDeclaration: function (node) {
+            handler.handleExportDefaultDeclaration(context, node, node, 'class');
+          },
+          ExportNamedDeclaration: function (node) {
+            handler.handleExportNamedDeclaration(context, node, node, 'class');
+          },
+          ClassExpression: function (node) {
+            handler.handleClassExpression(context, node, node, 'class');
+          },
+          ImportDeclaration: function (node) {
+            handler.handleImportDeclaration(context, node, node, 'class');
+          },
+          Identifier: function (node) {
+            handler.handleIdentifier(context, node, node, 'class');
+          }
         };
       },
-    },
+    };
+  }
 
-    'function-name': {
+  /**
+   * 创建类实例名规则
+   * @returns {object} 类实例名规则配置
+   */
+  createClassInstanceNameRule() {
+    var handler = this.handler;
+    
+    return {
       meta: {
         type: 'suggestion',
         docs: {
-          description: '检测函数名是否符合命名规范',
+          description: '检测类实例名是否符合命名规范',
           category: 'Stylistic Issues',
           recommended: true,
         },
@@ -137,71 +88,35 @@ function createNamingRules() {
       },
       create: function (context) {
         return {
-          FunctionDeclaration: function (node) {
-            if (node.id) {
-              var function_name = node.id.name;
-              var err = detector._checkFunctionName(function_name, node);
-              if (err) {
-                // 获取修复建议
-                var fix_suggestion = detector._getFixSuggestion(function_name, 'function-name', err.message);
-                
-                var report_obj = {
-                  node: err.node,
-                  message: err.message,
-                };
-                
-                // 如果有修复建议，添加修复功能
-                if (fix_suggestion) {
-                  report_obj.fix = function(fixer) {
-                    return fixer.replaceText(node.id, fix_suggestion.fixed_name);
-                  };
-                  // 只有当错误消息中不包含建议时才添加建议
-                  if (!err.message.includes('建议使用:')) {
-                    report_obj.message += '，建议使用: ' + fix_suggestion.fixed_name;
-                  }
-                }
-                
-                context.report(report_obj);
-              }
-            }
+          VariableDeclaration: function (node) {
+            handler.handleVariableDeclaration(context, node, node, 'class-instance');
           },
-          FunctionExpression: function (node) {
-            if (node.id) {
-              var function_name = node.id.name;
-              var err = detector._checkFunctionName(function_name, node);
-              if (err) {
-                // 获取修复建议
-                var fix_suggestion = detector._getFixSuggestion(function_name, 'function-name', err.message);
-                
-                var report_obj = {
-                  node: err.node,
-                  message: err.message,
-                };
-                
-                // 如果有修复建议，添加修复功能
-                if (fix_suggestion) {
-                  report_obj.fix = function(fixer) {
-                    return fixer.replaceText(node.id, fix_suggestion.fixed_name);
-                  };
-                  // 只有当错误消息中不包含建议时才添加建议
-                  if (!err.message.includes('建议使用:')) {
-                    report_obj.message += '，建议使用: ' + fix_suggestion.fixed_name;
-                  }
-                }
-                
-                context.report(report_obj);
-              }
-            }
+          Property: function (node) {
+            handler.handleProperty(context, node, node, 'class-instance');
+          },
+          AssignmentExpression: function (node) {
+            handler.handleAssignmentExpression(context, node, node, 'class-instance');
           },
+          PropertyDefinition: function (node) {
+            handler.handlePropertyDefinition(context, node, node, 'class-instance');
+          }
         };
       },
-    },
+    };
+  }
 
-    'function-call-name': {
+  /**
+   * 创建函数名规则
+   * @returns {object} 函数名规则配置
+   */
+  createFunctionNameRule() {
+    var handler = this.handler;
+    
+    return {
       meta: {
         type: 'suggestion',
         docs: {
-          description: '检测函数调用名是否符合命名规范',
+          description: '检测函数名是否符合命名规范',
           category: 'Stylistic Issues',
           recommended: true,
         },
@@ -209,191 +124,47 @@ function createNamingRules() {
         schema: [],
       },
       create: function (context) {
-        var self = this;
-        
         return {
+          FunctionDeclaration: function (node) {
+            handler.handleFunctionDeclaration(context, node, node, 'function');
+          },
+          FunctionExpression: function (node) {
+            handler.handleFunctionExpression(context, node, node, 'function');
+          },
+          ArrowFunctionExpression: function (node) {
+            handler.handleArrowFunctionExpression(context, node, node, 'function');
+          },
           CallExpression: function (node) {
-            if (node.callee && node.callee.type === 'Identifier') {
-              var function_name = node.callee.name;
-              
-              // 检查是否为参数名，如果是参数名则跳过检测（避免与参数名规则冲突）
-              if (_isParameterName(node.callee)) {
-                return;
-              }
-              
-              // 只检测函数调用名中的明显错误，如大写开头或蛇形命名
-              var err = detector._checkFunctionName(function_name, node);
-              if (err && (err.message.includes('不符合camelCase命名风格') || err.message.includes('不符合命名规范'))) {
-                // 获取修复建议
-                var fix_suggestion = detector._getFixSuggestion(function_name, 'function-name', err.message);
-                
-                // 根据错误类型生成具体的错误消息
-                var error_detail = '';
-                if (err.message.includes('不符合camelCase命名风格')) {
-                  error_detail = '不符合camelCase命名风格';
-                } else if (err.message.includes('长度过长')) {
-                  error_detail = '长度过长，最大长度为20字符';
-                } else if (err.message.includes('长度过短')) {
-                  error_detail = '长度过短，最小长度为1字符';
-                } else if (err.message.includes('单词过长')) {
-                  error_detail = '包含的单词过长，最大长度为8字符';
-                } else {
-                  error_detail = '不符合命名规范';
-                }
-                
-                var report_obj = {
-                  node: node.callee,
-                  message: '函数调用名\'' + function_name + '\'' + error_detail + '，建议使用: ' + (fix_suggestion ? fix_suggestion.fixed_name : '符合规范的名称'),
-                };
-                
-                // 如果有修复建议，添加修复功能
-                if (fix_suggestion) {
-                  report_obj.fix = function(fixer) {
-                    return fixer.replaceText(node.callee, fix_suggestion.fixed_name);
-                  };
-                }
-                
-                context.report(report_obj);
-              }
-            }
+            handler.handleCallExpression(context, node, node, 'function');
           },
-        };
-      },
-    },
-
-    'method-name': {
-      meta: {
-        type: 'suggestion',
-        docs: {
-          description: '检测方法名是否符合命名规范',
-          category: 'Stylistic Issues',
-          recommended: true,
-        },
-        fixable: 'code',
-        schema: [],
-      },
-      create: function (context) {
-        return {
           MethodDefinition: function (node) {
-            if (node.key && node.key.name) {
-              var method_name = node.key.name;
-              var err = detector._checkMethodName(method_name, node);
-              if (err) {
-                // 获取修复建议
-                var fix_suggestion = detector._getFixSuggestion(method_name, 'method-name', err.message);
-                
-                var report_obj = {
-                  node: err.node,
-                  message: err.message,
-                };
-                
-                // 如果有修复建议，添加修复功能
-                if (fix_suggestion) {
-                  report_obj.fix = function(fixer) {
-                    return fixer.replaceText(node.key, fix_suggestion.fixed_name);
-                  };
-                  // 只有当错误消息中不包含建议时才添加建议
-                  if (!err.message.includes('建议使用:')) {
-                    report_obj.message += '，建议使用: ' + fix_suggestion.fixed_name;
-                  }
-                }
-                
-                context.report(report_obj);
-              }
-            }
+            handler.handleMethodDefinition(context, node, node, 'function');
+          },
+          Property: function (node) {
+            handler.handleProperty(context, node, node, 'function');
+          },
+          PropertyDefinition: function (node) {
+            handler.handlePropertyDefinition(context, node, node, 'function');
           },
-          
-          // 处理原型方法定义：ClassName.prototype.method_name = function() {}
           AssignmentExpression: function (node) {
-            if (node.left && 
-                node.left.type === 'MemberExpression' &&
-                node.left.object && 
-                node.left.object.type === 'MemberExpression' &&
-                node.left.object.property && 
-                node.left.object.property.name === 'prototype' &&
-                node.left.property && 
-                node.left.property.type === 'Identifier' &&
-                node.right && 
-                (node.right.type === 'FunctionExpression' || node.right.type === 'ArrowFunctionExpression')) {
-              
-              var method_name = node.left.property.name;
-              var err = detector._checkMethodName(method_name, node);
-              if (err) {
-                // 检查是否为建议类型（不是错误）
-                if (err.type === 'suggestion') {
-                  // 建议性提示，直接使用返回的错误信息
-                  var report_obj = {
-                    node: node.left.property,
-                    message: err.message,
-                  };
-                } else {
-                  // 错误性提示，直接使用检测器返回的错误信息（已经包含推荐建议）
-                  var report_obj = {
-                    node: node.left.property,
-                    message: err.message,
-                  };
-                  
-                  // 如果有修复建议，添加修复功能
-                  var fix_suggestion = detector._getFixSuggestion(method_name, 'method-name', err.message);
-                  if (fix_suggestion) {
-                    report_obj.fix = function(fixer) {
-                      return fixer.replaceText(node.left.property, fix_suggestion.fixed_name);
-                    };
-                  }
-                }
-                
-                context.report(report_obj);
-              }
-            }
-            
-            // 处理类实例方法定义：this.method_name = function() {}
-            if (node.left && 
-                node.left.type === 'MemberExpression' &&
-                node.left.object && 
-                node.left.object.type === 'ThisExpression' &&
-                node.left.property && 
-                node.left.property.type === 'Identifier' &&
-                node.right && 
-                (node.right.type === 'FunctionExpression' || node.right.type === 'ArrowFunctionExpression')) {
-              
-              var method_name = node.left.property.name;
-              var err = detector._checkMethodName(method_name, node);
-              if (err) {
-                // 获取修复建议
-                var fix_suggestion = detector._getFixSuggestion(method_name, 'method-name', err.message);
-                
-                // 检查错误信息是否包含推荐词
-                var recommendation_match = err.message.match(/建议使用'([^']+)'/);
-                var recommended_name = recommendation_match ? recommendation_match[1] : null;
-                
-                var suggestion_text = '符合规范的名称';
-                if (fix_suggestion) {
-                  suggestion_text = fix_suggestion.fixed_name;
-                } else if (recommended_name) {
-                  suggestion_text = recommended_name;
-                }
-                
-                var report_obj = {
-                  node: node.left.property,
-                  message: '方法名\'' + method_name + '\'不符合命名规范，建议使用: ' + suggestion_text,
-                };
-                
-                // 如果有修复建议，添加修复功能
-                if (fix_suggestion) {
-                  report_obj.fix = function(fixer) {
-                    return fixer.replaceText(node.left.property, fix_suggestion.fixed_name);
-                  };
-                }
-                
-                context.report(report_obj);
-              }
-            }
+            handler.handleAssignmentExpression(context, node, node, 'function');
+          },
+          VariableDeclaration: function (node) {
+            handler.handleVariableDeclaration(context, node, node, 'function');
           },
         };
       },
-    },
+    };
+  }
 
-    'variable-name': {
+  /**
+   * 创建变量名规则
+   * @returns {object} 变量名规则配置
+   */
+  createVariableNameRule() {
+    var handler = this.handler;
+    
+    return {
       meta: {
         type: 'suggestion',
         docs: {
@@ -407,123 +178,45 @@ function createNamingRules() {
       create: function (context) {
         return {
           VariableDeclaration: function (node) {
-            // 排除const声明，只检测let和var声明的变量
-            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) {
-                    // 获取修复建议
-                    var fix_suggestion = detector._getFixSuggestion(variable_name, 'variable-name', err.message);
-                    
-                    var report_obj = {
-                      node: decl.id,
-                      message: err.message,
-                    };
-                    
-                    // 如果有修复建议，添加修复功能
-                    if (fix_suggestion) {
-                      report_obj.fix = function(fixer) {
-                        return fixer.replaceText(decl.id, fix_suggestion.fixed_name);
-                      };
-                      report_obj.message += '，建议使用: ' + fix_suggestion.fixed_name;
-                    }
-                    
-                    context.report(report_obj);
-                  }
-                }
-                // 处理解构赋值 - 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) {
-                        // 获取修复建议
-                        var fix_suggestion = detector._getFixSuggestion(variable_name, 'variable-name', err.message);
-                        
-                        var report_obj = {
-                          node: property.key,
-                          message: err.message,
-                        };
-                        
-                        // 如果有修复建议，添加修复功能
-                        if (fix_suggestion) {
-                          report_obj.fix = function(fixer) {
-                            return fixer.replaceText(property.key, fix_suggestion.fixed_name);
-                          };
-                          report_obj.message += '，建议使用: ' + fix_suggestion.fixed_name;
-                        }
-                        
-                        context.report(report_obj);
-                      }
-                    }
-                  });
-                }
-                // 处理解构赋值 - 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) {
-                        // 获取修复建议
-                        var fix_suggestion = detector._getFixSuggestion(variable_name, 'variable-name', err.message);
-                        
-                        var report_obj = {
-                          node: element,
-                          message: err.message,
-                        };
-                        
-                        // 如果有修复建议，添加修复功能
-                        if (fix_suggestion) {
-                          report_obj.fix = function(fixer) {
-                            return fixer.replaceText(element, fix_suggestion.fixed_name);
-                          };
-                          report_obj.message += '，建议使用: ' + fix_suggestion.fixed_name;
-                        }
-                        
-                        context.report(report_obj);
-                      }
-                    }
-                  });
-                }
-              });
+            handler.handleVariableDeclaration(context, node, node, 'variable');
+          },
+          ForStatement: function (node) {
+            if (node.init && node.init.type === 'VariableDeclaration') {
+              handler.handleVariableDeclaration(context, node, node.init, 'variable');
             }
           },
-        };
-      },
-    },
-
-    'param-name': {
-      meta: {
-        type: 'suggestion',
-        docs: {
-          description: '检测参数名是否符合命名规范',
-          category: 'Stylistic Issues',
-          recommended: true,
-        },
-        fixable: 'code',
-        schema: [],
-      },
-      create: function (context) {
-        return {
-          FunctionDeclaration: function (node) {
-            _fixParamAndReferences(context, node, detector);
+          ForInStatement: function (node) {
+            if (node.left && node.left.type === 'VariableDeclaration') {
+              handler.handleVariableDeclaration(context, node, node.left, 'variable');
+            }
           },
-          FunctionExpression: function (node) {
-            _fixParamAndReferences(context, node, detector);
+          ForOfStatement: function (node) {
+            if (node.left && node.left.type === 'VariableDeclaration') {
+              handler.handleVariableDeclaration(context, node, node.left, 'variable');
+            }
           },
-          ArrowFunctionExpression: function (node) {
-            _fixParamAndReferences(context, node, detector);
+          Property: function (node) {
+            handler.handleProperty(context, node, node, 'variable');
           },
+          PropertyDefinition: function (node) {
+            handler.handlePropertyDefinition(context, node, node, 'variable');
+          },
+          AssignmentExpression: function (node) {
+            handler.handleAssignmentExpression(context, node, node, 'variable');
+          }
         };
       },
-    },
+    };
+  }
 
-    'constant-name': {
+  /**
+   * 创建常量名规则
+   * @returns {object} 常量名规则配置
+   */
+  createConstantNameRule() {
+    var handler = this.handler;
+    
+    return {
       meta: {
         type: 'suggestion',
         docs: {
@@ -537,761 +230,115 @@ function createNamingRules() {
       create: function (context) {
         return {
           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) {
-                    var report_obj = {
-                      node: decl.id,
-                      message: err.message,
-                    };
-                    
-                    // 如果错误是"应该使用let而不是const"，提供const→let修复功能
-                    if (err.message.includes('应该使用let而不是const')) {
-                      report_obj.fix = function(fixer) {
-                        // 替换const为let
-                        var const_range = [node.range[0], node.range[0] + 5]; // const的位置
-                        return fixer.replaceTextRange(const_range, 'let');
-                      };
-                      report_obj.message += '，建议将const改为let';
-                    }
-                    // 否则提供命名风格修复建议
-                    else {
-                      // 使用检测器返回的规则类型（优先）
-                      var rule_type = err.rule_type || 'constant-name';
-                      
-                      // 如果没有返回规则类型，根据错误信息确定正确的规则类型
-                      if (!err.rule_type) {
-                        if (err.message.includes('函数名')) {
-                          rule_type = 'function-name';
-                        } else if (err.message.includes('变量名')) {
-                          rule_type = 'variable-name';
-                        } else if (err.message.includes('类名')) {
-                          rule_type = 'class-name';
-                        } else if (err.message.includes('属性名')) {
-                          rule_type = 'property-name';
-                        } else if (err.message.includes('方法名')) {
-                          rule_type = 'method-name';
-                        }
-                      }
-                      
-                      // 获取修复建议
-                      var fix_suggestion = detector._getFixSuggestion(constant_name, rule_type, err.message);
-                      
-                      // 如果有修复建议，添加修复功能
-                      if (fix_suggestion) {
-                        report_obj.fix = function(fixer) {
-                          return fixer.replaceText(decl.id, fix_suggestion.fixed_name);
-                        };
-                        
-                        // 只有当错误消息中不包含建议时才添加建议
-                        if (!err.message.includes('建议使用:')) {
-                          report_obj.message += '，建议使用: ' + fix_suggestion.fixed_name;
-                        }
-                      }
-                      
-                      // 设置正确的规则类型用于ESLint报告
-                      report_obj.ruleId = 'mm_eslint/' + rule_type;
-                    }
-                    
-                    context.report(report_obj);
-                  }
-                }
-                // 处理解构赋值 - 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) {
-                        var report_obj = {
-                          node: property.key,
-                          message: err.message,
-                        };
-                        
-                        // 如果错误是"应该使用let而不是const"，提供const→let修复功能
-                        if (err.message.includes('应该使用let而不是const')) {
-                          report_obj.fix = function(fixer) {
-                            // 替换const为let
-                            var const_range = [node.range[0], node.range[0] + 5]; // const的位置
-                            return fixer.replaceTextRange(const_range, 'let');
-                          };
-                          report_obj.message += '，建议将const改为let';
-                        }
-                        // 否则提供命名风格修复建议
-                        else {
-                          // 根据错误信息确定正确的规则类型
-                          var rule_type = 'constant-name';
-                          if (err.message.includes('函数名')) {
-                            rule_type = 'function-name';
-                          } else if (err.message.includes('变量名')) {
-                            rule_type = 'variable-name';
-                          } else if (err.message.includes('类名')) {
-                            rule_type = 'class-name';
-                          } else if (err.message.includes('属性名')) {
-                            rule_type = 'property-name';
-                          } else if (err.message.includes('方法名')) {
-                            rule_type = 'method-name';
-                          }
-                          
-                          // 获取修复建议
-                          var fix_suggestion = detector._getFixSuggestion(constant_name, rule_type, err.message);
-                          
-                          // 如果有修复建议，添加修复功能
-                          if (fix_suggestion) {
-                            report_obj.fix = function(fixer) {
-                              return fixer.replaceText(property.key, fix_suggestion.fixed_name);
-                            };
-                            report_obj.message += '，建议使用: ' + fix_suggestion.fixed_name;
-                          }
-                        }
-                        
-                        context.report(report_obj);
-                      }
-                    }
-                  });
-                }
-                // 处理解构赋值 - 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) {
-                        // 根据错误信息确定正确的规则类型
-                      var rule_type = 'variable-name';
-                      if (err.message.includes('函数名')) {
-                        rule_type = 'function-name';
-                      } else if (err.message.includes('变量名')) {
-                        rule_type = 'variable-name';
-                      } else if (err.message.includes('类名')) {
-                        rule_type = 'class-name';
-                      } else if (err.message.includes('属性名')) {
-                        rule_type = 'property-name';
-                      } else if (err.message.includes('方法名')) {
-                        rule_type = 'method-name';
-                      }
-                      
-                      // 获取修复建议
-                      var fix_suggestion = detector._getFixSuggestion(constant_name, rule_type, err.message);
-                      
-                      var report_obj = {
-                        node: element,
-                        message: err.message,
-                      };
-                      
-                      // 如果有修复建议，添加修复功能
-                      if (fix_suggestion) {
-                        report_obj.fix = function(fixer) {
-                          return fixer.replaceText(element, fix_suggestion.fixed_name);
-                        };
-                        report_obj.message += '，建议使用: ' + fix_suggestion.fixed_name;
-                      }
-                        
-                        context.report(report_obj);
-                      }
-                    }
-                  });
-                }
-              });
-            }
+            handler.handleVariableDeclaration(context, node, node, 'constant');
           },
-        };
-      },
-    },
-
-    'property-value-name': {
-      meta: {
-        type: 'suggestion',
-        docs: {
-          description: '属性值名命名规范检测',
-          category: 'Stylistic Issues',
-          recommended: true
-        },
-        fixable: 'code',
-        schema: []
-      },
-      create: function (context) {
-        return {
           Property: function (node) {
-          if (node.key && node.key.name) {
-            var prop_name = node.key.name;
-            
-            // 直接跳过null值和未赋值属性的检测
-            // 注意：null值的类型是Literal，但value为null
-            var is_null_value = node.value && node.value.type === 'Literal' && node.value.value === null;
-            var is_undefined_value = !node.value;
-            
-            if (is_null_value || is_undefined_value) {
-              // 对于null值和未赋值属性，直接跳过检测，不报错
-              return;
-            }
-            
-            // 传递祖父节点信息，用于第三方库排除检测
-            var parent_info = {
-              node: node.parent,
-              parent: node.parent ? node.parent.parent : null
-            };
-            
-            var err = detector._checkPropertyName(
-              prop_name,
-              node,
-              node.value,
-              parent_info,
-            );
-            
-            // 只处理属性值名相关的错误
-            if (err && err.rule_type === 'property-value-name') {
-              // 获取修复建议
-              var fix_suggestion = detector._getFixSuggestion(prop_name, 'property-value-name', err.message);
-              
-              var report_obj = {
-                node: err.node,
-                message: err.message,
-              };
-              
-              // 如果有修复建议，添加修复功能
-              if (fix_suggestion) {
-                report_obj.fix = function(fixer) {
-                  return fixer.replaceText(node.key, fix_suggestion.fixed_name);
-                };
-                report_obj.message += '，建议使用: ' + fix_suggestion.fixed_name;
-              }
-              
-              context.report(report_obj);
-            }
-          }
-        },
-          // 检测类实例属性 (this.xxx)
-          AssignmentExpression: function (node) {
-            // 检查是否是 this.xxx = value 形式的赋值
-            if (node.left && node.left.type === 'MemberExpression' &&
-                node.left.object && node.left.object.type === 'ThisExpression' &&
-                node.left.property && node.left.property.type === 'Identifier') {
-              
-              // 排除类实例方法：this.method_name = function() {}
-              var is_instance_method = 
-                node.right && 
-                (node.right.type === 'FunctionExpression' || node.right.type === 'ArrowFunctionExpression');
-              
-              if (is_instance_method) {
-                // 类实例方法由 method-name 规则处理，跳过
-                return;
-              }
-              
-              var prop_name = node.left.property.name;
-              
-              var parent_info = {
-                node: node.parent,
-                parent: node.parent ? node.parent.parent : null
-              };
-              
-              var err = detector._checkPropertyName(
-                prop_name,
-                node.left.property,
-                node.right,
-                parent_info,
-              );
-              
-              // 处理所有属性相关的错误类型，但排除 property-instance-class-name（由专门规则处理）
-              if (err && err.rule_type && err.rule_type.startsWith('property-') && 
-                  err.rule_type !== 'property-instance-class-name') {
-                // 获取修复建议
-                var fix_suggestion = detector._getFixSuggestion(prop_name, err.rule_type, err.message);
-                
-                var report_obj = {
-                  node: node.left.property,
-                  message: err.message,
-                };
-                
-                // 如果有修复建议，添加修复功能
-                if (fix_suggestion) {
-                  report_obj.fix = function(fixer) {
-                    return fixer.replaceText(node.left.property, fix_suggestion.fixed_name);
-                  };
-                  report_obj.message += '，建议使用: ' + fix_suggestion.fixed_name;
-                }
-                
-                context.report(report_obj);
-              }
-            }
+            handler.handleProperty(context, node, node, 'constant');
           },
-          // 检测普通属性赋值，排除原型方法
-          AssignmentExpression: function (node) {
-            if (
-              node.left &&
-              node.left.type === 'MemberExpression' &&
-              node.left.property &&
-              node.left.property.name
-            ) {
-              // 排除原型方法：ClassName.prototype.method_name = function() {}
-              var is_prototype_method = 
-                node.left.object && 
-                node.left.object.type === 'MemberExpression' &&
-                node.left.object.property && 
-                node.left.object.property.name === 'prototype' &&
-                node.right && 
-                (node.right.type === 'FunctionExpression' || node.right.type === 'ArrowFunctionExpression');
-              
-              if (is_prototype_method) {
-                // 原型方法由 method-name 规则处理，跳过
-                return;
-              }
-              
-              var prop_name = node.left.property.name;
-              
-              // 直接跳过null值和未赋值属性的检测
-              // 注意：null值的类型是Literal，但value为null
-              var is_null_value = node.right && node.right.type === 'Literal' && node.right.value === null;
-              var is_undefined_value = !node.right;
-              
-              if (is_null_value || is_undefined_value) {
-                // 对于null值和未赋值属性，直接跳过检测，不报错
-                return;
-              }
-              
-              var err = detector._checkPropertyName(
-                prop_name,
-                node,
-                node.right,
-                node.parent,
-              );
-              
-              // 只处理属性值名相关的错误
-              if (err && err.rule_type === 'property-value-name') {
-                  // 获取修复建议
-                  var fix_suggestion = detector._getFixSuggestion(prop_name, 'property-value-name', err.message);
-                
-                var report_obj = {
-                  node: err.node,
-                  message: err.message,
-                };
-                
-                // 如果有修复建议，添加修复功能
-                if (fix_suggestion) {
-                  report_obj.fix = function(fixer) {
-                    return fixer.replaceText(node.left.property, fix_suggestion.fixed_name);
-                  };
-                  report_obj.message += '，建议使用: ' + fix_suggestion.fixed_name;
-                }
-                
-                context.report(report_obj);
-              }
-            }
-          },
-        };
-      },
-    },
-
-    'property-method-name': {
-      meta: {
-        type: 'suggestion',
-        docs: {
-          description: '属性方法名命名规范检测',
-          category: 'Stylistic Issues',
-          recommended: true
-        },
-        fixable: 'code',
-        schema: []
-      },
-      create: function (context) {
-        return {
-          Property: function (node) {
-            if (node.key && node.key.name) {
-              var prop_name = node.key.name;
-              
-              // 传递祖父节点信息，用于第三方库排除检测
-              var parent_info = {
-                node: node.parent,
-                parent: node.parent ? node.parent.parent : null
-              };
-              
-              var err = detector._checkPropertyName(
-                prop_name,
-                node,
-                node.value,
-                parent_info,
-              );
-              
-              // 只处理属性方法名相关的错误
-              if (err && err.rule_type === 'property-method-name') {
-                // 获取修复建议
-                var fix_suggestion = detector._getFixSuggestion(prop_name, 'property-method-name', err.message);
-                
-                var report_obj = {
-                  node: err.node,
-                  message: err.message,
-                };
-                
-                // 如果有修复建议，添加修复功能
-                if (fix_suggestion) {
-                  report_obj.fix = function(fixer) {
-                    return fixer.replaceText(node.key, fix_suggestion.fixed_name);
-                  };
-                  report_obj.message += '，建议使用: ' + fix_suggestion.fixed_name;
-                }
-                
-                context.report(report_obj);
-              }
-            }
+          PropertyDefinition: function (node) {
+            handler.handlePropertyDefinition(context, node, node, 'constant');
           },
+          AssignmentExpression: function (node) {
+            handler.handleAssignmentExpression(context, node, node, 'constant');
+          }
         };
       },
-    },
+    };
+  }
 
-    'property-class-name': {
+  /**
+   * 创建参数名规则
+   * @returns {object} 参数名规则配置
+   */
+  createParamNameRule() {
+    var handler = this.handler;
+    
+    return {
       meta: {
         type: 'suggestion',
         docs: {
-          description: '属性类名命名规范检测',
+          description: '检测参数名是否符合命名规范',
           category: 'Stylistic Issues',
-          recommended: true
+          recommended: true,
         },
         fixable: 'code',
-        schema: []
+        schema: [],
       },
       create: function (context) {
         return {
-          Property: function (node) {
-            if (node.key && node.key.name) {
-              var prop_name = node.key.name;
-              
-              // 传递祖父节点信息，用于第三方库排除检测
-              var parent_info = {
-                node: node.parent,
-                parent: node.parent ? node.parent.parent : null
-              };
-              
-              var err = detector._checkPropertyName(
-                prop_name,
-                node,
-                node.value,
-                parent_info,
-              );
-              
-              // 只处理属性类名相关的错误
-              if (err && err.rule_type === 'property-class-name') {
-                // 获取修复建议
-                var fix_suggestion = detector._getFixSuggestion(prop_name, 'property-class-name', err.message);
-                
-                var report_obj = {
-                  node: err.node,
-                  message: err.message,
-                };
-                
-                // 如果有修复建议，添加修复功能
-                if (fix_suggestion) {
-                  report_obj.fix = function(fixer) {
-                    return fixer.replaceText(node.key, fix_suggestion.fixed_name);
-                  };
-                  report_obj.message += '，建议使用: ' + fix_suggestion.fixed_name;
+          FunctionDeclaration: function (node) {
+            if (node.params && node.params.length > 0) {
+              for (var i = 0; i < node.params.length; i++) {
+                var param = node.params[i];
+                if (param.type === 'Identifier') {
+                  var result = handler.detector.detect(param, param.name);
+                  if (result) {
+                    result.node = param;
+                    result.fix = handler.fix.createParamFixFunction(context, param, result);
+                    context.report(result);
+                  }
                 }
-                
-                context.report(report_obj);
               }
             }
           },
-        };
-      },
-    },
-
-    'property-instance-class-name': {
-      meta: {
-        type: 'suggestion',
-        docs: {
-          description: '属性实例类名命名规范检测',
-          category: 'Stylistic Issues',
-          recommended: true
-        },
-        fixable: 'code',
-        schema: []
-      },
-      create: function (context) {
-        return {
-          // 检测对象字面量中的属性实例类名
-          Property: function (node) {
-            if (node.key && node.key.name) {
-              var prop_name = node.key.name;
-              
-              // 传递祖父节点信息，用于第三方库排除检测
-              var parent_info = {
-                node: node.parent,
-                parent: node.parent ? node.parent.parent : null
-              };
-              
-              // 检测属性命名
-              var err = detector._checkPropertyName(
-                prop_name,
-                node.key,
-                node.value,
-                parent_info,
-              );
-              
-              // 只处理属性实例类名相关的错误
-              if (err && err.rule_type === 'property-instance-class-name') {
-                // 获取修复建议
-                var fix_suggestion = detector._getFixSuggestion(prop_name, 'property-instance-class-name', err.message);
-                
-                var report_obj = {
-                  node: err.node,
-                  message: err.message,
-                };
-                
-                // 如果有修复建议，添加修复功能
-                if (fix_suggestion) {
-                  report_obj.fix = function(fixer) {
-                    return fixer.replaceText(node.key, fix_suggestion.fixed_name);
-                  };
-                  report_obj.message += '，建议使用: ' + fix_suggestion.fixed_name;
+          FunctionExpression: function (node) {
+            if (node.params && node.params.length > 0) {
+              for (var i = 0; i < node.params.length; i++) {
+                var param = node.params[i];
+                if (param.type === 'Identifier') {
+                  var result = handler.detector.detect(param, param.name);
+                  if (result) {
+                    result.node = param;
+                    result.fix = handler.fix.createParamFixFunction(context, param, result);
+                    context.report(result);
+                  }
                 }
-                
-                context.report(report_obj);
               }
             }
           },
-          
-          // 检测类实例属性中的属性实例类名 (this.xxx)
-          AssignmentExpression: function (node) {
-            // 检查是否是 this.xxx = value 形式的赋值
-            if (node.left && node.left.type === 'MemberExpression' &&
-                node.left.object && node.left.object.type === 'ThisExpression' &&
-                node.left.property && node.left.property.type === 'Identifier') {
-              
-              // 排除类实例方法：this.method_name = function() {}
-              var is_instance_method = 
-                node.right && 
-                (node.right.type === 'FunctionExpression' || node.right.type === 'ArrowFunctionExpression');
-              
-              if (is_instance_method) {
-                // 类实例方法由 method-name 规则处理，跳过
-                return;
-              }
-              
-              var prop_name = node.left.property.name;
-              
-              var parent_info = {
-                node: node.parent,
-                parent: node.parent ? node.parent.parent : null
-              };
-              
-              // 检测属性命名
-              var err = detector._checkPropertyName(
-                prop_name,
-                node.left.property,
-                node.right,
-                parent_info,
-              );
-              
-              // 只处理属性实例类名相关的错误
-              if (err && err.rule_type === 'property-instance-class-name') {
-                // 获取修复建议
-                var fix_suggestion = detector._getFixSuggestion(prop_name, 'property-instance-class-name', err.message);
-                
-                var report_obj = {
-                  node: err.node,
-                  message: err.message,
-                };
-                
-                // 如果有修复建议，添加修复功能
-                if (fix_suggestion) {
-                  report_obj.fix = function(fixer) {
-                    return fixer.replaceText(node.left.property, fix_suggestion.fixed_name);
-                  };
-                  report_obj.message += '，建议使用: ' + fix_suggestion.fixed_name;
+          ArrowFunctionExpression: function (node) {
+            if (node.params && node.params.length > 0) {
+              for (var i = 0; i < node.params.length; i++) {
+                var param = node.params[i];
+                if (param.type === 'Identifier') {
+                  var result = handler.detector.detect(param, param.name);
+                  if (result) {
+                    result.node = param;
+                    result.fix = handler.fix.createParamFixFunction(context, param, result);
+                    context.report(result);
+                  }
                 }
-                
-                context.report(report_obj);
               }
             }
-          },
-        };
-      },
-    },
-
-    'param-reference-consistency': {
-      meta: {
-        type: 'problem',
-        docs: {
-          description: '检测参数声明与函数内部引用是否一致',
-          category: 'Possible Errors',
-          recommended: true,
-        },
-        fixable: 'code',
-        schema: [],
-      },
-      create: function (context) {
-        return {
-          FunctionDeclaration: function (node) {
-            detector._checkParamReferences(context, node);
-          },
-          FunctionExpression: function (node) {
-            detector._checkParamReferences(context, node);
-          },
-          ArrowFunctionExpression: function (node) {
-            detector._checkParamReferences(context, node);
-          },
+          }
         };
       },
-    },
-  };
-}
+    };
+  }
 
-/**
- * 修复参数声明和所有相关引用
- * @param {object} context ESLint上下文
- * @param {object} node 函数节点
- * @param {object} detector 检测器实例
- */
-function _fixParamAndReferences(context, node, detector) {
-  if (!node.params || !node.body) return;
-  
-  // 收集需要修复的参数映射
-  var param_fixes = [];
-  
-  node.params.forEach(function(param) {
-    if (param.name) {
-      var param_name = param.name;
-      var err = detector._checkParamName(param_name, param);
-      if (err) {
-        var fix_suggestion = detector._getFixSuggestion(param_name, 'param-name', err.message);
-        if (fix_suggestion && fix_suggestion.fixed_name !== param_name) {
-          param_fixes.push({
-            param_node: param,
-            old_name: param_name,
-            new_name: fix_suggestion.fixed_name,
-            message: err.message + '，建议使用: ' + fix_suggestion.fixed_name
-          });
-        }
-      }
-    }
-  });
-  
-  // 如果没有需要修复的参数，直接返回
-  if (param_fixes.length === 0) return;
-  
-  // 分步修复：先修复参数声明，然后单独检测引用不一致问题
-  param_fixes.forEach(function(fix_info) {
-    // 第一步：修复参数声明
-    context.report({
-      node: fix_info.param_node,
-      message: fix_info.message,
-      fix: function(fixer) {
-        return fixer.replaceText(fix_info.param_node, fix_info.new_name);
-      }
-    });
-    
-    // 第二步：检测并修复函数体内的引用不一致问题
-    _checkParamReferenceInconsistencies(context, node, fix_info);
-  });
+  /**
+   * 获取所有规则
+   * @returns {object} 所有规则配置
+   */
+  getAllRules() {
+    return {
+      'class-name': this.createClassNameRule(),
+      'class-instance-name': this.createClassInstanceNameRule(),
+      'function-name': this.createFunctionNameRule(),
+      'variable-name': this.createVariableNameRule(),
+      'constant-name': this.createConstantNameRule(),
+      'param-name': this.createParamNameRule()
+    };
+  }
 }
 
 /**
- * 检查并修复参数引用不一致问题
- * @param {object} context ESLint上下文
- * @param {object} node 函数节点
- * @param {object} fix_info 修复信息
+ * 创建ESLint规则配置
+ * @returns {object} ESLint规则配置对象
  */
-function _checkParamReferenceInconsistencies(context, node, fix_info) {
-  var source_code = context.getSourceCode();
-  
-  // 使用深度优先搜索遍历AST
-  function findIdentifierReferences(astNode, oldName) {
-    var references = [];
-    var visited = new Set();
-    
-    function traverse(currentNode) {
-      // 防止循环引用导致的无限递归
-      if (!currentNode || visited.has(currentNode) || typeof currentNode !== 'object') {
-        return;
-      }
-      visited.add(currentNode);
-      
-      // 检查当前节点是否为标识符节点
-      if (currentNode.type === 'Identifier' && currentNode.name === oldName) {
-        // 排除参数声明节点本身
-        if (currentNode !== fix_info.param_node) {
-          references.push(currentNode);
-        }
-      }
-      
-      // 深度优先遍历所有子节点
-      var stack = [currentNode];
-      
-      while (stack.length > 0) {
-        var current = stack.pop();
-        
-        // 遍历当前节点的所有属性
-        Object.keys(current).forEach(function(key) {
-          // 跳过可能引起循环的属性
-          if (key === 'parent' || key === 'range' || key === 'loc' || key === 'comments') {
-            return;
-          }
-          
-          var child = current[key];
-          
-          if (child && typeof child === 'object') {
-            if (Array.isArray(child)) {
-              // 将数组元素逆序压入栈中，保持遍历顺序
-              for (var i = child.length - 1; i >= 0; i--) {
-                var item = child[i];
-                if (item && typeof item === 'object' && !visited.has(item)) {
-                  visited.add(item);
-                  
-                  // 检查是否为标识符节点
-                  if (item.type === 'Identifier' && item.name === oldName && item !== fix_info.param_node) {
-                    references.push(item);
-                  }
-                  
-                  stack.push(item);
-                }
-              }
-            } else if (!visited.has(child)) {
-              visited.add(child);
-              
-              // 检查是否为标识符节点
-              if (child.type === 'Identifier' && child.name === oldName && child !== fix_info.param_node) {
-                references.push(child);
-              }
-              
-              stack.push(child);
-            }
-          }
-        });
-      }
-    }
-    
-    traverse(astNode);
-    return references;
-  }
-  
-  // 查找函数体内的所有引用
-  var references = findIdentifierReferences(node.body, fix_info.old_name);
-  
-  // 如果找到引用，创建一个包含所有修复的单一修复函数
-  if (references.length > 0) {
-    context.report({
-      node: node,
-      message: '参数引用不一致：' + fix_info.old_name + ' 应该使用 ' + fix_info.new_name + ' (找到 ' + references.length + ' 个引用)',
-      fix: function(fixer) {
-        var fixes = [];
-        
-        // 为每个引用添加修复
-        references.forEach(function(refNode) {
-          fixes.push(fixer.replaceText(refNode, fix_info.new_name));
-        });
-        
-        // 返回所有修复的数组
-        return fixes;
-      }
-    });
-  }
+function createNamingRules() {
+  var rules = new Rules();
+  return rules.getAllRules();
 }
 
-module.exports = {
-  rules: createNamingRules(),
-};
+module.exports = createNamingRules();