mm_eslint 1.0.1 → 1.0.2

package/index.js

@@ -3,91 +3,120 @@
 /**
  * 命名规范检测器类
  */
-class NamingDetector {
+class Detector {
   static config = {
     forbidden_words: [
       'manager', 'handler', 'processor', 'controller',
       'Management', 'Handler', 'Processor', 'Controller',
       'LoggerManager', 'AppState', 'UserHandler'
     ],
+    regex: {
+      'PascalCase': /^[A-Z][a-zA-Z]*$/, // 大驼峰：大写字母开头，只包含字母。主要用于类名
+      'camelCase': /^[a-z][a-zA-Z]*$/, // 小驼峰：小写字母开头，只包含字母。主要用于方法名、函数名
+      'snake_case': /^[a-z][a-z0-9_]*(_[a-z0-9]+)*$/, // 小写蛇形：小写字母开头，可包含下划线。主要用于变量名、入参名
+      'UPPER_SNAKE_CASE': /^[A-Z][A-Z0-9_]*(_[A-Z0-9]+)*$/, // 大写蛇形：大写字母开头，可包含下划线。主要用于常量名
+      'kebab-case': /^[a-z][a-z0-9-]*(-[a-z0-9]+)*$/, // 小写横杠：小写字母开头，可包含短横线，小写短横线。主要用于资源名、路由路径
+      'UPPER-KEBAB-CASE': /^[A-Z][A-Z0-9-]*(-[A-Z0-9]+)*$/, // 大写横杠：大写字母开头，可包含短横线，大写短横线。主要用于资源名、路由路径
+      'lowercase': /^[a-z][a-z0-9]*$/, // 小写单词：小写字母开头，只包含小写字母和数字。主要用于对象、属性名
+      'UPPERCASE': /^[A-Z][A-Z0-9]*$/, // 大写单词：大写字母开头，只包含大写字母和数字。主要用于枚举值、常量名
+      'camelCase-kebab': /^[a-z][a-z0-9-]*(-[a-z0-9]+)*$/, // 支持横杠小驼峰：小写字母开头，可包含短横线，小写短横线。主要用于资源名、路由路径
+      'PascalCase-kebab': /^[A-Z][a-zA-Z]*$/, // 支持横杠大驼峰：大写字母开头，只包含字母。主要用于资源名、路由路径
+      '_camelCase': /^_[a-z][a-zA-Z]*$/, // 下划线小驼峰：下划线加小写字母开头，只包含字母。主要用于私有方法名
+      '_snake_case': /^_[a-z][a-z0-9_]*(_[a-z0-9]+)*$/, // 下划线小写蛇形：下划线加小写字母开头，可包含下划线。主要用于私有变量名
+      '_lowercase': /^_[a-z][a-z0-9]*$/, // 下划线小写单词：下划线加小写字母开头，只包含小写字母和数字。主要用于对象、属性名
+    },
+
     // 类名大驼峰规则
     'class-name': {
       name: '类名',
-      message: '{type}{name}必须使用大驼峰命名法（PascalCase），长度{min}-{max}字符，且优先使用单个单词',
-      regex: /^[A-Z][a-zA-Z]*$/, // 大写字母开头，只包含字母
+      message: '必须使用大驼峰命名法（PascalCase），长度{min}-{max}字符，且优先使用单个单词，每个单词不超过{word_len}字符',
+      regex: null, // 使用styles属性进行验证
       min: 1,
-      max: 20
+      max: 20,
+      styles: ['PascalCase'],
+      single_word: true,
+      single_word_len: 8
     },
 
     // 函数名小驼峰规则
     'function-name': {
       name: '函数名',
-      message: '必须使用小驼峰命名法（camelCase），长度{min}-{max}字符，且优先使用单个单词',
-      regex: /^[a-z][a-zA-Z]*$/, // 小写字母开头，只包含字母
+      message: '必须使用小驼峰命名法（camelCase），长度{min}-{max}字符，且优先使用单个单词，每个单词不超过{word_len}字符',
+      regex: null, // 使用styles属性进行验证
       min: 1,
       max: 20,
-      single_word_preferred: true
+      styles: ['camelCase'],
+      single_word: true,
+      single_word_len: 8
     },
 
     // 方法名小驼峰规则
     'method-name': {
       name: '方法名',
-      message: '必须使用小驼峰命名法（camelCase），长度{min}-{max}字符，且优先使用单个单词',
-      regex: /^[a-z][a-zA-Z]*$/, // 小写字母开头，只包含字母
+      message: '必须使用小驼峰命名法（camelCase），长度{min}-{max}字符，且优先使用单个单词，每个单词不超过{word_len}字符',
+      regex: null, // 使用styles属性进行验证
       min: 1,
       max: 20,
-      single_word_preferred: true
+      styles: ['camelCase'],
+      single_word: true,
+      single_word_len: 8
     },
 
     // 入参名小写蛇形规则
     'param-name': {
       name: '入参名',
       message: '必须使用小写蛇形命名法（snake_case），长度{min}-{max}字符',
-      regex: /^[a-z][a-z0-9_]*(_[a-z0-9]+)*$/, // 小写字母开头，可包含下划线
+      regex: null, // 使用styles属性进行验证
       min: 1,
-      max: 20
+      max: 20,
+      styles: ['lowercase', 'snake_case']
     },
 
     // 变量名小写蛇形规则
     'variable-name': {
       name: '变量名',
       message: '必须使用小写蛇形命名法（snake_case），长度{min}-{max}字符',
-      regex: /^[a-z][a-z0-9_]*(_[a-z0-9]+)*$/, // 小写字母开头，可包含下划线
+      regex: null, // 使用styles属性进行验证
       min: 1,
-      max: 20
+      max: 20,
+      styles: ['lowercase', 'snake_case']
     },
 
     // 常量名大写蛇形规则
     'constant-name': {
       name: '常量名',
       message: '必须使用大写蛇形命名法（UPPER_SNAKE_CASE），长度{min}-{max}字符',
-      regex: /^[A-Z][A-Z0-9_]*(_[A-Z0-9]+)*$/, // 大写字母开头，可包含下划线
+      regex: null, // 使用styles属性进行验证
       min: 1,
-      max: 20
+      max: 20,
+      styles: ['UPPERCASE', 'UPPER_SNAKE_CASE']
     },
 
-    // 属性名小写蛇形规则
+    // 属性名多风格规则（根据值类型应用不同规则）
     'property-name': {
       name: '属性名',
-      message: '必须使用小写蛇形命名法（snake_case），长度{min}-{max}字符',
-      regex: /^[a-z][a-z0-9_]*(_[a-z0-9]+)*$/, // 小写字母开头，可包含下划线
+      message: '根据属性值类型应用不同命名规则',
       min: 1,
-      max: 20
+      max: 20,
+      single_word: true,
+      single_word_len: 8,
+      styles: ['lowercase', '_lowercase', 'UPPERCASE', 'snake_case', '_snake_case']
     },
 
     // 私有方法/属性规则
     'private-naming': {
       name: '私有成员',
       message: '必须以单下划线开头，后跟小写蛇形命名，长度{min}-{max}字符',
-      regex: /^_[a-z][a-z0-9_]*(_[a-z0-9]+)*$/, // 下划线开头，小写蛇形
+      regex: null, // 使用styles属性进行验证
       min: 2,
-      max: 20
+      max: 20,
+      styles: ['_lowercase', '_snake_case', '_camelCase']
     }
   }
 
   constructor(config) {
     // 合并默认配置和传入配置
-    const merged_config = { ...NamingDetector.config };
+    const merged_config = { ...Detector.config };
     if (config && typeof config === 'object') {
       Object.keys(config).forEach(key => {
         if (merged_config[key]) {
@@ -116,29 +145,40 @@ class NamingDetector {
     this._init_rules();
   }
 
-  _new_model() {
-    return {
-      name: '',
-      message: '',
-      regex: null,
-      min: 1,
-      max: 20
-    }
-  }
 
-  _init_rules() {
-    // 绑定规则检查方法
-    this._rules = {
-      'class-name': this._checkName.bind(this, 'class-name'),
-      'function-name': this._checkName.bind(this, 'function-name'),
-      'method-name': this._checkName.bind(this, 'method-name'),
-      'param-name': this._checkName.bind(this, 'param-name'),
-      'variable-name': this._checkName.bind(this, 'variable-name'),
-      'constant-name': this._checkName.bind(this, 'constant-name'),
-      'property-name': this._checkName.bind(this, 'property-name'),
-      'private-naming': this._checkName.bind(this, 'private-naming')
-    };
-  }
+}
+
+/**
+ * 创建新的规则模型
+ * @returns {Object} 规则模型
+ * @private
+ */
+Detector.prototype._new_model = function () {
+  return {
+    name: '',
+    message: '',
+    regex: null,
+    min: 1,
+    max: 20
+  };
+}
+
+/**
+ * 初始化规则检查方法
+ * @private
+ */
+Detector.prototype._init_rules = function () {
+  // 绑定规则检查方法
+  this._rules = {
+    'class-name': this._checkName.bind(this, 'class-name'),
+    'function-name': this._checkName.bind(this, 'function-name'),
+    'method-name': this._checkName.bind(this, 'method-name'),
+    'param-name': this._checkName.bind(this, 'param-name'),
+    'variable-name': this._checkName.bind(this, 'variable-name'),
+    'constant-name': this._checkName.bind(this, 'constant-name'),
+    'property-name': this._checkPropertyName.bind(this),
+    'private-naming': this._checkName.bind(this, 'private-naming')
+  };
 }
 
 /**
@@ -148,7 +188,7 @@ class NamingDetector {
  * @returns {Object} 检查结果
  * @private
  */
-NamingDetector.prototype._checkName = function (rule_type, name) {
+Detector.prototype._checkName = function (rule_type, name) {
   if (!name) {
     throw new TypeError('名称不能为空');
   }
@@ -159,6 +199,7 @@ NamingDetector.prototype._checkName = function (rule_type, name) {
   }
 
   const errors = [];
+  const warnings = [];
 
   // 检查长度
   if (name.length < config.min) {
@@ -168,15 +209,32 @@ NamingDetector.prototype._checkName = function (rule_type, name) {
     errors.push(`${config.name}长度不能超过${config.max}个字符`);
   }
 
-  // 检查正则表达式
-  if (config.regex && !config.regex.test(name)) {
-    const error_message = config.message
-      .replace('{name}', `"${name}"`)
-      .replace('{type}', config.name)
-      .replace('{min}', config.min)
-      .replace('{max}', config.max)
-      .replace('{regex}', config.regex.toString());
-    errors.push(error_message);
+  // 检查命名规则（优先使用regex，如果regex为空则使用styles）
+  let name_valid = false;
+  
+  if (config.regex && config.regex.toString() !== '/(?:)/') {
+    // 使用regex进行验证
+    name_valid = config.regex.test(name);
+    if (!name_valid) {
+      const error_message = config.message
+        .replace('{name}', `"${name}"`)
+        .replace('{type}', config.name)
+        .replace('{min}', config.min)
+        .replace('{max}', config.max)
+        .replace('{word_len}', config.single_word_len || 8)
+        .replace('{regex}', config.regex.toString());
+      errors.push(error_message);
+    }
+  } else if (config.styles && config.styles.length > 0) {
+    // 使用styles进行验证
+    name_valid = this._checkNameByStyles(name, config.styles);
+    if (!name_valid) {
+      const allowed_styles = config.styles.join('、');
+      errors.push(`${config.name}必须符合以下命名风格之一：${allowed_styles}`);
+    }
+  } else {
+    // 既没有regex也没有styles，跳过命名格式检查
+    name_valid = true;
   }
 
   // 检查禁止词汇
@@ -184,26 +242,253 @@ NamingDetector.prototype._checkName = function (rule_type, name) {
     errors.push(`${config.name}包含禁止的废话词`);
   }
 
-  // 检查是否优先使用单个单词
-  if (config.single_word_preferred) {
-    if (name.includes('_') || name.includes('-')) {
-      errors.push(`${config.name}应优先使用单个单词`);
+  // 检查是否优先使用单个单词（警告级别）
+  if (config.single_word) {
+    // 检测驼峰命名中的大写字母（表示多单词组合）
+    // 排除第一个字母后，检查是否包含大写字母（表示多单词）
+    const has_uppercase = /[A-Z]/.test(name.slice(1));
+    // 检测下划线或连字符
+    const has_separators = name.includes('_') || name.includes('-');
+    
+    // 对于函数名和方法名，需要更精确地检测多单词
+    // getName（get前缀+单个单词）不算多单词，getUserName（get前缀+多单词）才算多单词
+    const is_function_or_method = rule_type === 'function-name' || rule_type === 'method-name';
+    let is_multi_word = has_uppercase || has_separators;
+    
+    if (is_function_or_method && is_multi_word) {
+      // 检查是否是add/del/set/get/is/has等前缀后跟单个单词
+      const prefix_match = name.match(/^(add|del|set|get|is|has|can|not)([A-Z][a-z]*)$/);
+      if (prefix_match && prefix_match[2]) {
+        // 如果前缀后只有一个单词，不算多单词
+        is_multi_word = false;
+      }
+    }
+    
+    if (is_multi_word) {
+      warnings.push(`${config.name}应优先使用单个单词`);
+    }
+  }
+
+  // 检查单个单词长度限制
+  if (config.single_word_len && config.single_word_len > 0) {
+    const words = this._splitWords(name, rule_type);
+    const long_words = words.filter(word => word.length > config.single_word_len);
+    
+    if (long_words.length > 0) {
+      errors.push(`${config.name}中的单词"${long_words.join('、')}"超过${config.single_word_len}个字符限制`);
     }
   }
 
   return {
     valid: errors.length === 0,
-    errors: errors
+    errors: errors,
+    warnings: warnings
   };
 }
 
+/**
+ * 根据styles列表检查名称是否符合命名风格
+ * @param {string} name - 名称
+ * @param {Array} styles - 命名风格列表
+ * @returns {boolean} 是否符合任一风格
+ * @private
+ */
+Detector.prototype._checkNameByStyles = function (name, styles) {
+  if (!name || !styles || styles.length === 0) {
+    return false;
+  }
+
+  // 检查名称是否符合任一指定的命名风格
+  for (const style of styles) {
+    const regex = this.config.regex[style];
+    if (regex && regex.test(name)) {
+      return true;
+    }
+  }
+  
+  return false;
+}
+
+/**
+ * 拆分名称中的单词
+ * @param {string} name - 名称
+ * @param {string} rule_type - 规则类型
+ * @returns {Array} 拆分后的单词数组
+ * @private
+ */
+Detector.prototype._splitWords = function (name, rule_type) {
+  if (!name) {
+    return [];
+  }
+
+  const words = [];
+  
+  // 根据命名风格拆分单词
+  if (name.includes('_')) {
+    // 蛇形命名：user_name → ["user", "name"]
+    words.push(...name.split('_').filter(word => word.length > 0));
+  } else if (name.includes('-')) {
+    // 横杠命名：user-name → ["user", "name"]
+    words.push(...name.split('-').filter(word => word.length > 0));
+  } else {
+    // 驼峰命名：userName → ["user", "Name"]
+    // 使用正则表达式拆分驼峰命名
+    const camel_case_words = name.split(/(?=[A-Z])/);
+    
+    // 对于函数名和方法名，处理常见前缀
+    if (rule_type === 'function-name' || rule_type === 'method-name') {
+      const prefix_match = name.match(/^(add|del|set|get|is|has|can|not)([A-Z].*)$/);
+      if (prefix_match) {
+        // 如果是前缀+单词的组合，将前缀作为单独单词
+        words.push(prefix_match[1]);
+        // 拆分剩余部分
+        const remaining_words = prefix_match[2].split(/(?=[A-Z])/);
+        words.push(...remaining_words);
+      } else {
+        words.push(...camel_case_words);
+      }
+    } else {
+      words.push(...camel_case_words);
+    }
+  }
+  
+  // 过滤空字符串并转换为小写进行比较
+  return words.filter(word => word.length > 0).map(word => word.toLowerCase());
+}
+
+/**
+ * 属性名检查方法（根据属性值类型应用不同规则）
+ * @param {string} name - 属性名
+ * @param {Object} value_node - 属性值AST节点
+ * @returns {Object} 检查结果
+ * @private
+ */
+Detector.prototype._checkPropertyName = function (name, value_node) {
+  if (!name) {
+    throw new TypeError('属性名不能为空');
+  }
+
+  const config = this.config['property-name'];
+  if (!config) {
+    throw new Error('属性名规则配置不存在');
+  }
+
+  const errors = [];
+  const warnings = [];
+
+  // 检查长度
+  if (name.length < config.min) {
+    errors.push(`${config.name}长度不能少于${config.min}个字符`);
+  }
+  if (name.length > config.max) {
+    errors.push(`${config.name}长度不能超过${config.max}个字符`);
+  }
+
+  // 检查禁止词汇
+  if (this._hasForbiddenWords(name)) {
+    errors.push(`${config.name}包含禁止的废话词`);
+  }
+
+  // 根据属性值类型应用不同的命名规则
+  const value_type = this._getPropertyValueType(value_node);
+  
+  switch (value_type) {
+    case 'function':
+      // 函数属性：使用函数名检测规则
+      const function_result = this._checkName('function-name', name);
+      if (!function_result.valid) {
+        errors.push(`${config.name}（函数属性）${function_result.errors.join(', ')}`);
+      }
+      break;
+      
+    case 'class':
+      // 类属性：使用类名检测规则
+      const class_result = this._checkName('class-name', name);
+      if (!class_result.valid) {
+        errors.push(`${config.name}（类属性）${class_result.errors.join(', ')}`);
+      }
+      break;
+      
+    case 'value':
+    default:
+      // 值属性：使用styles配置检查命名风格
+      const is_uppercase_snake = /^[A-Z][A-Z0-9_]*(_[A-Z0-9]+)+$/.test(name); // 包含下划线的大写蛇形
+      const is_uppercase_multi = /^[A-Z][A-Z0-9]*[A-Z][A-Z0-9]*$/.test(name); // 多单词大写组合（没有下划线）
+
+      // 检查是否为大写蛇形（禁止）
+      if (is_uppercase_snake || is_uppercase_multi) {
+        errors.push(`${config.name}（值属性）禁止使用大写蛇形命名（如PRODUCT_ID或PRODUCTID）`);
+      }
+
+      // 使用styles配置检查命名风格
+      if (config.styles && config.styles.length > 0) {
+        const is_valid_style = this._checkNameByStyles(name, config.styles);
+        if (!is_valid_style && !is_uppercase_snake && !is_uppercase_multi) {
+          const allowed_styles = config.styles.join('、');
+          errors.push(`${config.name}（值属性）必须符合以下命名风格之一：${allowed_styles}`);
+        }
+      }
+      break;
+  }
+
+  // 检查是否优先使用单个单词（警告级别）
+  if (config.single_word) {
+    // 检测驼峰命名中的大写字母（表示多单词组合）
+    const has_uppercase = /[A-Z]/.test(name.slice(1));
+    // 检测下划线或连字符
+    const has_separators = name.includes('_') || name.includes('-');
+    
+    if (has_uppercase || has_separators) {
+      warnings.push(`${config.name}应优先使用单个单词`);
+    }
+  }
+
+  return {
+    valid: errors.length === 0,
+    errors: errors,
+    warnings: warnings,
+    value_type: value_type
+  };
+}
+
+/**
+ * 获取属性值类型
+ * @param {Object} value_node - 属性值AST节点
+ * @returns {string} 属性值类型（'function', 'class', 'value'）
+ * @private
+ */
+Detector.prototype._getPropertyValueType = function (value_node) {
+  if (!value_node) {
+    return 'value'; // 默认值类型
+  }
+
+  // 检查是否为函数
+  if (value_node.type === 'FunctionExpression' || 
+      value_node.type === 'ArrowFunctionExpression' ||
+      (value_node.type === 'Identifier' && value_node.name && 
+       (value_node.name.endsWith('Function') || value_node.name.endsWith('Func') ||
+        value_node.name.startsWith('on') || value_node.name.startsWith('handle')))) {
+    return 'function';
+  }
+
+  // 检查是否为类
+  if (value_node.type === 'ClassExpression' ||
+      (value_node.type === 'Identifier' && value_node.name && 
+       /^[A-Z][a-zA-Z]*$/.test(value_node.name))) {
+    return 'class';
+  }
+
+  // 默认为值类型
+  return 'value';
+}
+
 /**
  * 检查是否包含禁止的废话词
  * @param {string} name - 名称
  * @returns {boolean} 是否包含禁止词
  * @private
  */
-NamingDetector.prototype._hasForbiddenWords = function (name) {
+Detector.prototype._hasForbiddenWords = function (name) {
   if (!name) {
     return false;
   }
@@ -221,7 +506,7 @@ NamingDetector.prototype._hasForbiddenWords = function (name) {
  * @param {string} type - 类型（class/function/variable/constant/private）
  * @returns {Object} 检测结果
  */
-NamingDetector.prototype.checkName = function (name, type) {
+Detector.prototype.checkName = function (name, type) {
   if (typeof name !== 'string' || !name.trim()) {
     return {
       valid: false,
@@ -260,7 +545,7 @@ NamingDetector.prototype.checkName = function (name, type) {
  * @param {string} type - 类型
  * @returns {Array} 检测结果数组
  */
-NamingDetector.prototype.checkNames = function (names, type) {
+Detector.prototype.checkNames = function (names, type) {
   if (!Array.isArray(names)) {
     throw new TypeError('名称必须是数组');
   }
@@ -275,7 +560,7 @@ NamingDetector.prototype.checkNames = function (names, type) {
 /**
  * 类名大驼峰规则
  */
-const classNameRule = {
+const class_name_rule = {
   meta: {
     type: 'suggestion',
     docs: {
@@ -291,7 +576,9 @@ const classNameRule = {
           min: { type: 'number' },
           max: { type: 'number' },
           message: { type: 'string' },
-          single_word_preferred: { type: 'boolean' }
+          single_word: { type: 'boolean' },
+          single_word_len: { type: 'number' },
+          styles: { type: 'array', items: { type: 'string' } }
         },
         additionalProperties: false
       }
@@ -302,7 +589,7 @@ const classNameRule = {
     return {
       ClassDeclaration(node) {
         const class_name = node.id.name;
-        const detector = new NamingDetector({ 'class-name': options });
+        const detector = new Detector({ 'class-name': options });
         const result = detector.checkName(class_name, 'class-name');
 
         if (!result.valid) {
@@ -321,7 +608,7 @@ const classNameRule = {
 /**
  * 函数名小驼峰规则
  */
-const functionNameRule = {
+const function_name_rule = {
   meta: {
     type: 'suggestion',
     docs: {
@@ -337,7 +624,9 @@ const functionNameRule = {
           min: { type: 'number' },
           max: { type: 'number' },
           message: { type: 'string' },
-          single_word_preferred: { type: 'boolean' }
+          single_word: { type: 'boolean' },
+          single_word_len: { type: 'number' },
+          styles: { type: 'array', items: { type: 'string' } }
         },
         additionalProperties: false
       }
@@ -349,7 +638,7 @@ const functionNameRule = {
       FunctionDeclaration(node) {
         const function_name = node.id ? node.id.name : 'anonymous';
         if (function_name !== 'anonymous') {
-          const detector = new NamingDetector({ 'function-name': options });
+          const detector = new Detector({ 'function-name': options });
           const result = detector.checkName(function_name, 'function-name');
 
           if (!result.valid) {
@@ -366,7 +655,7 @@ const functionNameRule = {
       FunctionExpression(node) {
         if (node.id) {
           const function_name = node.id.name;
-          const detector = new NamingDetector({ 'function-name': options });
+          const detector = new Detector({ 'function-name': options });
           const result = detector.checkName(function_name, 'function-name');
 
           if (!result.valid) {
@@ -386,7 +675,7 @@ const functionNameRule = {
 /**
  * 方法名小驼峰规则
  */
-const methodNameRule = {
+const method_name_rule = {
   meta: {
     type: 'suggestion',
     docs: {
@@ -402,7 +691,9 @@ const methodNameRule = {
           min: { type: 'number' },
           max: { type: 'number' },
           message: { type: 'string' },
-          single_word_preferred: { type: 'boolean' }
+          single_word: { type: 'boolean' },
+          single_word_len: { type: 'number' },
+          styles: { type: 'array', items: { type: 'string' } }
         },
         additionalProperties: false
       }
@@ -413,7 +704,13 @@ const methodNameRule = {
     return {
       MethodDefinition(node) {
         const method_name = node.key.name;
-        const detector = new NamingDetector({ 'method-name': options });
+        
+        // 跳过私有方法的检测（私有方法由private-naming规则处理）
+        if (method_name.startsWith('_')) {
+          return;
+        }
+        
+        const detector = new Detector({ 'method-name': options });
         const result = detector.checkName(method_name, 'method-name');
 
         if (!result.valid) {
@@ -432,7 +729,7 @@ const methodNameRule = {
 /**
  * 变量名小写蛇形规则
  */
-const variableNameRule = {
+const variable_name_rule = {
   meta: {
     type: 'suggestion',
     docs: {
@@ -448,7 +745,9 @@ const variableNameRule = {
           min: { type: 'number' },
           max: { type: 'number' },
           message: { type: 'string' },
-          single_word_preferred: { type: 'boolean' }
+          single_word: { type: 'boolean' },
+          single_word_len: { type: 'number' },
+          styles: { type: 'array', items: { type: 'string' } }
         },
         additionalProperties: false
       }
@@ -456,11 +755,39 @@ const variableNameRule = {
   },
   create(context) {
     const options = context.options[0] || {};
+    
+    function isRealConstant(node) {
+      // 真正的常量特征：
+      // 1. 在模块顶层作用域（不在函数或块内）
+      // 2. 名称包含大写字母（表示意图作为常量）
+      
+      // 检查是否在模块顶层
+      let scope_node = node;
+      while (scope_node.parent) {
+        scope_node = scope_node.parent;
+        if (scope_node.type === 'FunctionDeclaration' || 
+            scope_node.type === 'FunctionExpression' ||
+            scope_node.type === 'ArrowFunctionExpression' ||
+            scope_node.type === 'BlockStatement') {
+          return false; // 在函数或块内，不是真正的常量
+        }
+      }
+      
+      // 检查名称是否包含大写字母（表示意图作为常量）
+      const name = node.id.name;
+      return /[A-Z]/.test(name);
+    }
+    
     return {
       VariableDeclarator(node) {
         if (node.id.type === 'Identifier') {
+          // 对于const声明，只对不是真正常量的应用变量命名规则
+          if (node.parent.kind === 'const' && isRealConstant(node)) {
+            return; // 这是真正的常量，由常量规则处理
+          }
+          
           const variable_name = node.id.name;
-          const detector = new NamingDetector({ 'variable-name': options });
+          const detector = new Detector({ 'variable-name': options });
           const result = detector.checkName(variable_name, 'variable-name');
 
           if (!result.valid) {
@@ -480,7 +807,7 @@ const variableNameRule = {
 /**
  * 常量名大写蛇形规则
  */
-const constantNameRule = {
+const constant_name_rule = {
   meta: {
     type: 'suggestion',
     docs: {
@@ -496,7 +823,9 @@ const constantNameRule = {
           min: { type: 'number' },
           max: { type: 'number' },
           message: { type: 'string' },
-          single_word_preferred: { type: 'boolean' }
+          single_word: { type: 'boolean' },
+          single_word_len: { type: 'number' },
+          styles: { type: 'array', items: { type: 'string' } }
         },
         additionalProperties: false
       }
@@ -504,18 +833,162 @@ const constantNameRule = {
   },
   create(context) {
     const options = context.options[0] || {};
+    
+    function isRealConstant(node) {
+      // 真正的常量特征：
+      // 1. 在模块顶层作用域（不在函数或块内）
+      // 2. 名称包含大写字母（表示意图作为常量）
+      // 3. 或者名称是常见的常量模式（如全大写）
+      
+      // 检查是否在模块顶层
+      let scope_node = node;
+      while (scope_node.parent) {
+        scope_node = scope_node.parent;
+        if (scope_node.type === 'FunctionDeclaration' || 
+            scope_node.type === 'FunctionExpression' ||
+            scope_node.type === 'ArrowFunctionExpression' ||
+            scope_node.type === 'BlockStatement') {
+          return false; // 在函数或块内，不是真正的常量
+        }
+      }
+      
+      // 检查名称是否包含大写字母（表示意图作为常量）
+      const name = node.id.name;
+      return /[A-Z]/.test(name);
+    }
+    
     return {
       VariableDeclarator(node) {
         if (node.id.type === 'Identifier' && node.parent.kind === 'const') {
-          const constant_name = node.id.name;
-          const detector = new NamingDetector({ 'constant-name': options });
-          const result = detector.checkName(constant_name, 'constant-name');
+          // 只对真正的常量应用常量命名规则
+          if (isRealConstant(node)) {
+            const constant_name = node.id.name;
+            const detector = new Detector({ 'constant-name': options });
+            const result = detector.checkName(constant_name, 'constant-name');
+
+            if (!result.valid) {
+              result.errors.forEach(error => {
+                context.report({
+                  node: node.id,
+                  message: `常量名"${constant_name}"不符合规范: ${error}`
+                });
+              });
+            }
+          }
+        }
+      }
+    };
+  }
+};
+
+/**
+ * 入参名小写蛇形规则
+ */
+const param_name_rule = {
+  meta: {
+    type: 'suggestion',
+    docs: {
+      description: '入参名必须使用小写蛇形命名法（snake_case）',
+      category: 'Stylistic Issues',
+      recommended: true
+    },
+    schema: [
+      {
+        type: 'object',
+        properties: {
+          regex: { type: 'string' },
+          min: { type: 'number' },
+          max: { type: 'number' },
+          message: { type: 'string' },
+          single_word: { type: 'boolean' },
+          single_word_len: { type: 'number' },
+          styles: { type: 'array', items: { type: 'string' } }
+        },
+        additionalProperties: false
+      }
+    ]
+  },
+  create(context) {
+    const options = context.options[0] || {};
+    
+    function checkParam(node) {
+      node.params.forEach(param => {
+        if (param.type === 'Identifier') {
+          const param_name = param.name;
+          const detector = new Detector({ 'param-name': options });
+          const result = detector.checkName(param_name, 'param-name');
 
           if (!result.valid) {
             result.errors.forEach(error => {
               context.report({
-                node: node.id,
-                message: `常量名"${constant_name}"不符合规范: ${error}`
+                node: param,
+                message: `入参名"${param_name}"不符合规范: ${error}`
+              });
+            });
+          }
+        }
+      });
+    }
+    
+    return {
+      FunctionDeclaration: checkParam,
+      FunctionExpression: checkParam,
+      ArrowFunctionExpression: checkParam
+    };
+  }
+};
+
+/**
+ * 属性名小写蛇形规则
+ */
+const property_name_rule = {
+  meta: {
+    type: 'suggestion',
+    docs: {
+      description: '属性名必须使用小写蛇形命名法（snake_case）',
+      category: 'Stylistic Issues',
+      recommended: true
+    },
+    schema: [
+      {
+        type: 'object',
+        properties: {
+          regex: { type: 'string' },
+          min: { type: 'number' },
+          max: { type: 'number' },
+          message: { type: 'string' },
+          single_word: { type: 'boolean' },
+          single_word_len: { type: 'number' },
+          styles: { type: 'array', items: { type: 'string' } }
+        },
+        additionalProperties: false
+      }
+    ]
+  },
+  create(context) {
+    const options = context.options[0] || {};
+    return {
+      Property(node) {
+        // 检测类属性、对象字面量属性、模块导出属性
+        const is_class_property = node.parent && 
+          (node.parent.type === 'ClassBody' || 
+           (node.parent.type === 'ObjectExpression' && 
+            node.parent.parent && 
+            node.parent.parent.type === 'ClassDeclaration'));
+        
+        const is_object_property = node.parent && node.parent.type === 'ObjectExpression';
+        
+        // 检测所有非私有属性（不以_开头）
+        if (node.key.type === 'Identifier' && !node.key.name.startsWith('_')) {
+          const property_name = node.key.name;
+          const detector = new Detector({ 'property-name': options });
+          const result = detector._checkPropertyName(property_name, node.value);
+
+          if (!result.valid) {
+            result.errors.forEach(error => {
+              context.report({
+                node: node.key,
+                message: `属性名"${property_name}"不符合规范: ${error}`
               });
             });
           }
@@ -528,7 +1001,7 @@ const constantNameRule = {
 /**
  * 私有成员命名规则
  */
-const privateNamingRule = {
+const private_naming_rule = {
   meta: {
     type: 'suggestion',
     docs: {
@@ -544,7 +1017,9 @@ const privateNamingRule = {
           min: { type: 'number' },
           max: { type: 'number' },
           message: { type: 'string' },
-          single_word_preferred: { type: 'boolean' }
+          single_word: { type: 'boolean' },
+          single_word_len: { type: 'number' },
+          styles: { type: 'array', items: { type: 'string' } }
         },
         additionalProperties: false
       }
@@ -556,7 +1031,7 @@ const privateNamingRule = {
       MethodDefinition(node) {
         const method_name = node.key.name;
         if (method_name.startsWith('_')) {
-          const detector = new NamingDetector({ 'private-naming': options });
+          const detector = new Detector({ 'private-naming': options });
           const result = detector.checkName(method_name, 'private-naming');
 
           if (!result.valid) {
@@ -573,7 +1048,7 @@ const privateNamingRule = {
       Property(node) {
         if (node.key.type === 'Identifier' && node.key.name.startsWith('_')) {
           const private_name = node.key.name;
-          const detector = new NamingDetector({ 'private-naming': options });
+          const detector = new Detector({ 'private-naming': options });
           const result = detector.checkName(private_name, 'private-naming');
 
           if (!result.valid) {
@@ -593,16 +1068,18 @@ const privateNamingRule = {
 /**
  * 命名规范ESLint插件
  */
-const namingRules = {
-  'class-name': classNameRule,
-  'function-name': functionNameRule,
-  'method-name': methodNameRule,
-  'variable-name': variableNameRule,
-  'constant-name': constantNameRule,
-  'private-naming': privateNamingRule
+const naming_rules = {
+  'class-name': class_name_rule,
+  'function-name': function_name_rule,
+  'method-name': method_name_rule,
+  'variable-name': variable_name_rule,
+  'constant-name': constant_name_rule,
+  'private-naming': private_naming_rule,
+  'param-name': param_name_rule,
+  'property-name': property_name_rule
 };
 
 module.exports = {
-  NamingDetector,
-  rules: namingRules
+  Detector,
+  rules: naming_rules
 };