mm_eslint 1.0.1

package/LICENSE

@@ -0,0 +1,15 @@
+ISC License
+
+Copyright (c) 2025 Admin
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted, provided that the above
+copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.

package/README.md

@@ -0,0 +1,202 @@
+# MM ESLint Plugin
+
+基于个人命名规范的ESLint插件，支持类名、函数名、变量名、常量名等命名规范检测。
+
+## 功能特性
+
+- ✅ **类名检测** - 大驼峰命名法（PascalCase）
+- ✅ **函数名检测** - 小驼峰命名法（camelCase）
+- ✅ **方法名检测** - 小驼峰命名法（camelCase）
+- ✅ **变量名检测** - 小写蛇形命名法（snake_case）
+- ✅ **常量名检测** - 大写蛇形命名法（UPPER_SNAKE_CASE）
+- ✅ **私有成员检测** - 下划线开头的小写蛇形命名
+- ✅ **长度限制** - 所有命名长度限制在1-20字符
+- ✅ **单个单词优先** - 鼓励使用单个单词命名
+- ✅ **禁止废话词** - 避免使用Manager、Handler等冗余词汇
+
+## 安装
+
+### npm安装
+
+```bash
+npm install mm-eslint-plugin --save-dev
+```
+
+### 本地安装
+
+如果您想使用本地版本，可以将插件文件复制到项目中：
+
+```bash
+# 复制插件文件到您的项目
+cp mm-eslint-plugin/index.js your-project/eslint-plugins/
+```
+
+## 快速开始
+
+### 1. 基本配置
+
+在您的ESLint配置文件中引入插件：
+
+```javascript
+// eslint.config.js
+const namingConventionPlugin = require('mm-eslint-plugin');
+
+module.exports = [
+  {
+    files: ['**/*.js'],
+    plugins: {
+      'naming-convention': namingConventionPlugin
+    },
+    rules: {
+      'naming-convention/class-name': 'error',
+      'naming-convention/function-name': 'error',
+      'naming-convention/method-name': 'error',
+      'naming-convention/variable-name': 'warn',
+      'naming-convention/constant-name': 'error',
+      'naming-convention/private-naming': 'warn'
+    }
+  }
+];
+```
+
+### 2. 命令行使用
+
+```bash
+# 验证单个文件
+npx eslint your-file.js
+
+# 验证所有JS文件
+npx eslint "**/*.js"
+
+# 验证并自动修复
+npx eslint --fix your-file.js
+```
+
+## 命名规范规则
+
+### 类名规则（class-name）
+- **级别**: error
+- **要求**: 大驼峰命名法（PascalCase）
+- **长度**: 1-20字符
+- **示例**: `UserService`, `ProductManager`
+- **错误示例**: `userService`, `USER_SERVICE`
+
+### 函数名规则（function-name）
+- **级别**: error
+- **要求**: 小驼峰命名法（camelCase）
+- **长度**: 1-20字符
+- **优先**: 单个单词
+- **示例**: `getUser`, `calculateTotal`
+- **错误示例**: `GetUser`, `get_user`
+
+### 方法名规则（method-name）
+- **级别**: error
+- **要求**: 小驼峰命名法（camelCase）
+- **长度**: 1-20字符
+- **优先**: 单个单词
+- **示例**: `getName`, `setValue`
+- **错误示例**: `GetName`, `get_name`
+
+### 变量名规则（variable-name）
+- **级别**: warn
+- **要求**: 小写蛇形命名法（snake_case）
+- **长度**: 1-20字符
+- **优先**: 单个单词
+- **示例**: `user_count`, `max_retry`
+- **错误示例**: `userCount`, `MAX_RETRY`
+
+### 常量名规则（constant-name）
+- **级别**: error
+- **要求**: 大写蛇形命名法（UPPER_SNAKE_CASE）
+- **长度**: 1-20字符
+- **示例**: `MAX_RETRY`, `DEFAULT_TIMEOUT`
+- **错误示例**: `maxRetry`, `defaultTimeout`
+
+### 私有成员规则（private-naming）
+- **级别**: warn
+- **要求**: 下划线开头的小写蛇形命名
+- **长度**: 2-20字符
+- **示例**: `_user_count`, `_internal_data`
+- **错误示例**: `userCount`, `_UserCount`
+
+## 错误示例
+
+```javascript
+// ❌ 错误的命名示例
+class userService {          // 类名应该大驼峰
+const GetUser = function() {}; // 函数名应该小驼峰
+let maxRetryCount = 5;       // 变量名应该小写蛇形
+const userCount = 10;        // 常量名应该大写蛇形
+
+// ✅ 正确的命名示例
+class UserService {
+  constructor() {
+    this._user_count = 0;    // 私有属性正确
+  }
+  
+  getUser() {                // 方法名正确
+    return this._user_count;
+  }
+}
+
+const MAX_RETRY = 5;         // 常量名正确
+let user_count = 10;         // 变量名正确
+```
+
+## 配置选项
+
+您可以通过配置自定义规则参数：
+
+```javascript
+// 自定义配置示例
+const customConfig = {
+  'class-name': {
+    regex: /^[A-Z][a-zA-Z]*$/,
+    min: 1,
+    max: 25,  // 扩展最大长度
+    message: '类名{name}必须使用大驼峰命名法'
+  }
+};
+
+const detector = new NamingDetector(customConfig);
+```
+
+## 开发
+
+### 项目结构
+
+```
+mm-eslint-plugin/
+├── index.js          # 主插件文件
+├── package.json      # npm配置
+├── eslint.config.js  # ESLint配置
+├── test.js           # 单元测试
+├── example.js        # 使用示例
+└── README.md         # 说明文档
+```
+
+### 运行测试
+
+```bash
+# 运行单元测试
+npm test
+
+# 运行ESLint检查
+npm run lint
+```
+
+## 许可证
+
+ISC License
+
+## 贡献
+
+欢迎提交Issue和Pull Request来改进这个插件。
+
+## 更新日志
+
+### v1.0.0
+- 初始版本发布
+- 支持类名、函数名、方法名、变量名、常量名、私有成员命名规范检测
+- 支持长度限制和单个单词优先规则
+- 支持禁止废话词检测

package/README_EN.md

@@ -0,0 +1,202 @@
+# MM ESLint Plugin
+
+An ESLint plugin based on personal naming conventions, supporting naming convention detection for class names, function names, variable names, constant names, and more.
+
+## Features
+
+- ✅ **Class Name Detection** - PascalCase naming convention
+- ✅ **Function Name Detection** - camelCase naming convention
+- ✅ **Method Name Detection** - camelCase naming convention
+- ✅ **Variable Name Detection** - snake_case naming convention
+- ✅ **Constant Name Detection** - UPPER_SNAKE_CASE naming convention
+- ✅ **Private Member Detection** - underscore-prefixed snake_case naming
+- ✅ **Length Restrictions** - All names limited to 1-20 characters
+- ✅ **Single Word Preferred** - Encourages single word naming
+- ✅ **Forbidden Words** - Avoids redundant words like Manager, Handler, etc.
+
+## Installation
+
+### npm Installation
+
+```bash
+npm install mm-eslint-plugin --save-dev
+```
+
+### Local Installation
+
+If you want to use a local version, you can copy the plugin files to your project:
+
+```bash
+# Copy plugin files to your project
+cp mm-eslint-plugin/index.js your-project/eslint-plugins/
+```
+
+## Quick Start
+
+### 1. Basic Configuration
+
+Import the plugin in your ESLint configuration file:
+
+```javascript
+// eslint.config.js
+const namingConventionPlugin = require('mm-eslint-plugin');
+
+module.exports = [
+  {
+    files: ['**/*.js'],
+    plugins: {
+      'naming-convention': namingConventionPlugin
+    },
+    rules: {
+      'naming-convention/class-name': 'error',
+      'naming-convention/function-name': 'error',
+      'naming-convention/method-name': 'error',
+      'naming-convention/variable-name': 'warn',
+      'naming-convention/constant-name': 'error',
+      'naming-convention/private-naming': 'warn'
+    }
+  }
+];
+```
+
+### 2. Command Line Usage
+
+```bash
+# Validate a single file
+npx eslint your-file.js
+
+# Validate all JS files
+npx eslint "**/*.js"
+
+# Validate and auto-fix
+npx eslint --fix your-file.js
+```
+
+## Naming Convention Rules
+
+### Class Name Rule (class-name)
+- **Level**: error
+- **Requirement**: PascalCase naming convention
+- **Length**: 1-20 characters
+- **Examples**: `UserService`, `ProductManager`
+- **Invalid Examples**: `userService`, `USER_SERVICE`
+
+### Function Name Rule (function-name)
+- **Level**: error
+- **Requirement**: camelCase naming convention
+- **Length**: 1-20 characters
+- **Preference**: Single word
+- **Examples**: `getUser`, `calculateTotal`
+- **Invalid Examples**: `GetUser`, `get_user`
+
+### Method Name Rule (method-name)
+- **Level**: error
+- **Requirement**: camelCase naming convention
+- **Length**: 1-20 characters
+- **Preference**: Single word
+- **Examples**: `getName`, `setValue`
+- **Invalid Examples**: `GetName`, `get_name`
+
+### Variable Name Rule (variable-name)
+- **Level**: warn
+- **Requirement**: snake_case naming convention
+- **Length**: 1-20 characters
+- **Preference**: Single word
+- **Examples**: `user_count`, `max_retry`
+- **Invalid Examples**: `userCount`, `MAX_RETRY`
+
+### Constant Name Rule (constant-name)
+- **Level**: error
+- **Requirement**: UPPER_SNAKE_CASE naming convention
+- **Length**: 1-20 characters
+- **Examples**: `MAX_RETRY`, `DEFAULT_TIMEOUT`
+- **Invalid Examples**: `maxRetry`, `defaultTimeout`
+
+### Private Member Rule (private-naming)
+- **Level**: warn
+- **Requirement**: underscore-prefixed snake_case naming
+- **Length**: 2-20 characters
+- **Examples**: `_user_count`, `_internal_data`
+- **Invalid Examples**: `userCount`, `_UserCount`
+
+## Error Examples
+
+```javascript
+// ❌ Invalid naming examples
+class userService {          // Class name should be PascalCase
+const GetUser = function() {}; // Function name should be camelCase
+let maxRetryCount = 5;       // Variable name should be snake_case
+const userCount = 10;        // Constant name should be UPPER_SNAKE_CASE
+
+// ✅ Correct naming examples
+class UserService {
+  constructor() {
+    this._user_count = 0;    // Private property correct
+  }
+  
+  getUser() {                // Method name correct
+    return this._user_count;
+  }
+}
+
+const MAX_RETRY = 5;         // Constant name correct
+let user_count = 10;         // Variable name correct
+```
+
+## Configuration Options
+
+You can customize rule parameters through configuration:
+
+```javascript
+// Custom configuration example
+const customConfig = {
+  'class-name': {
+    regex: /^[A-Z][a-zA-Z]*$/,
+    min: 1,
+    max: 25,  // Extend maximum length
+    message: 'Class name {name} must use PascalCase naming convention'
+  }
+};
+
+const detector = new NamingDetector(customConfig);
+```
+
+## Development
+
+### Project Structure
+
+```
+mm-eslint-plugin/
+├── index.js          # Main plugin file
+├── package.json      # npm configuration
+├── eslint.config.js  # ESLint configuration
+├── test.js           # Unit tests
+├── example.js        # Usage examples
+└── README.md         # Documentation
+```
+
+### Running Tests
+
+```bash
+# Run unit tests
+npm test
+
+# Run ESLint checks
+npm run lint
+```
+
+## License
+
+ISC License
+
+## Contributing
+
+Welcome to submit Issues and Pull Requests to improve this plugin.
+
+## Changelog
+
+### v1.0.0
+- Initial version release
+- Support for class name, function name, method name, variable name, constant name, and private member naming convention detection
+- Support for length restrictions and single word preference rules
+- Support for forbidden words detection

package/index.js

@@ -0,0 +1,608 @@
+'use strict';
+
+/**
+ * 命名规范检测器类
+ */
+class NamingDetector {
+  static config = {
+    forbidden_words: [
+      'manager', 'handler', 'processor', 'controller',
+      'Management', 'Handler', 'Processor', 'Controller',
+      'LoggerManager', 'AppState', 'UserHandler'
+    ],
+    // 类名大驼峰规则
+    'class-name': {
+      name: '类名',
+      message: '{type}{name}必须使用大驼峰命名法（PascalCase），长度{min}-{max}字符，且优先使用单个单词',
+      regex: /^[A-Z][a-zA-Z]*$/, // 大写字母开头，只包含字母
+      min: 1,
+      max: 20
+    },
+
+    // 函数名小驼峰规则
+    'function-name': {
+      name: '函数名',
+      message: '必须使用小驼峰命名法（camelCase），长度{min}-{max}字符，且优先使用单个单词',
+      regex: /^[a-z][a-zA-Z]*$/, // 小写字母开头，只包含字母
+      min: 1,
+      max: 20,
+      single_word_preferred: true
+    },
+
+    // 方法名小驼峰规则
+    'method-name': {
+      name: '方法名',
+      message: '必须使用小驼峰命名法（camelCase），长度{min}-{max}字符，且优先使用单个单词',
+      regex: /^[a-z][a-zA-Z]*$/, // 小写字母开头，只包含字母
+      min: 1,
+      max: 20,
+      single_word_preferred: true
+    },
+
+    // 入参名小写蛇形规则
+    'param-name': {
+      name: '入参名',
+      message: '必须使用小写蛇形命名法（snake_case），长度{min}-{max}字符',
+      regex: /^[a-z][a-z0-9_]*(_[a-z0-9]+)*$/, // 小写字母开头，可包含下划线
+      min: 1,
+      max: 20
+    },
+
+    // 变量名小写蛇形规则
+    'variable-name': {
+      name: '变量名',
+      message: '必须使用小写蛇形命名法（snake_case），长度{min}-{max}字符',
+      regex: /^[a-z][a-z0-9_]*(_[a-z0-9]+)*$/, // 小写字母开头，可包含下划线
+      min: 1,
+      max: 20
+    },
+
+    // 常量名大写蛇形规则
+    'constant-name': {
+      name: '常量名',
+      message: '必须使用大写蛇形命名法（UPPER_SNAKE_CASE），长度{min}-{max}字符',
+      regex: /^[A-Z][A-Z0-9_]*(_[A-Z0-9]+)*$/, // 大写字母开头，可包含下划线
+      min: 1,
+      max: 20
+    },
+
+    // 属性名小写蛇形规则
+    'property-name': {
+      name: '属性名',
+      message: '必须使用小写蛇形命名法（snake_case），长度{min}-{max}字符',
+      regex: /^[a-z][a-z0-9_]*(_[a-z0-9]+)*$/, // 小写字母开头，可包含下划线
+      min: 1,
+      max: 20
+    },
+
+    // 私有方法/属性规则
+    'private-naming': {
+      name: '私有成员',
+      message: '必须以单下划线开头，后跟小写蛇形命名，长度{min}-{max}字符',
+      regex: /^_[a-z][a-z0-9_]*(_[a-z0-9]+)*$/, // 下划线开头，小写蛇形
+      min: 2,
+      max: 20
+    }
+  }
+
+  constructor(config) {
+    // 合并默认配置和传入配置
+    const merged_config = { ...NamingDetector.config };
+    if (config && typeof config === 'object') {
+      Object.keys(config).forEach(key => {
+        if (merged_config[key]) {
+          merged_config[key] = { ...merged_config[key], ...config[key] };
+          
+          // 处理字符串形式的正则表达式
+          if (typeof merged_config[key].regex === 'string') {
+            try {
+              // 从字符串中提取正则表达式模式和标志
+              const regex_match = merged_config[key].regex.match(/^\/(.*)\/([gimuy]*)$/);
+              if (regex_match) {
+                merged_config[key].regex = new RegExp(regex_match[1], regex_match[2]);
+              } else {
+                // 如果不是标准的正则表达式字符串格式，直接创建
+                merged_config[key].regex = new RegExp(merged_config[key].regex);
+              }
+            } catch (error) {
+              console.warn(`无效的正则表达式: ${merged_config[key].regex}`, error);
+              merged_config[key].regex = null;
+            }
+          }
+        }
+      });
+    }
+    this.config = merged_config;
+    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')
+    };
+  }
+}
+
+/**
+ * 通用命名检查方法
+ * @param {string} rule_type - 规则类型
+ * @param {string} name - 名称
+ * @returns {Object} 检查结果
+ * @private
+ */
+NamingDetector.prototype._checkName = function (rule_type, name) {
+  if (!name) {
+    throw new TypeError('名称不能为空');
+  }
+
+  const config = this.config[rule_type];
+  if (!config) {
+    throw new Error(`不支持的规则类型: ${rule_type}`);
+  }
+
+  const errors = [];
+
+  // 检查长度
+  if (name.length < config.min) {
+    errors.push(`${config.name}长度不能少于${config.min}个字符`);
+  }
+  if (name.length > config.max) {
+    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);
+  }
+
+  // 检查禁止词汇
+  if (this._hasForbiddenWords(name)) {
+    errors.push(`${config.name}包含禁止的废话词`);
+  }
+
+  // 检查是否优先使用单个单词
+  if (config.single_word_preferred) {
+    if (name.includes('_') || name.includes('-')) {
+      errors.push(`${config.name}应优先使用单个单词`);
+    }
+  }
+
+  return {
+    valid: errors.length === 0,
+    errors: errors
+  };
+}
+
+/**
+ * 检查是否包含禁止的废话词
+ * @param {string} name - 名称
+ * @returns {boolean} 是否包含禁止词
+ * @private
+ */
+NamingDetector.prototype._hasForbiddenWords = function (name) {
+  if (!name) {
+    return false;
+  }
+
+  const forbidden_words = this.config.forbidden_words || [];
+
+  return forbidden_words.some(word =>
+    name.toLowerCase().includes(word.toLowerCase())
+  );
+}
+
+/**
+ * 检测名称是否符合规范
+ * @param {string} name - 名称
+ * @param {string} type - 类型（class/function/variable/constant/private）
+ * @returns {Object} 检测结果
+ */
+NamingDetector.prototype.checkName = function (name, type) {
+  if (typeof name !== 'string' || !name.trim()) {
+    return {
+      valid: false,
+      errors: ['名称必须是有效的字符串']
+    };
+  }
+
+  if (typeof type !== 'string' || !type.trim()) {
+    return {
+      valid: false,
+      errors: ['类型必须是有效的字符串']
+    };
+  }
+
+  const rule_method = this._rules[type];
+  if (!rule_method) {
+    return {
+      valid: false,
+      errors: [`不支持的类型: ${type}`]
+    };
+  }
+
+  try {
+    return rule_method(name);
+  } catch (error) {
+    return {
+      valid: false,
+      errors: [`检测名称时出错: ${error.message}`]
+    };
+  }
+}
+
+/**
+ * 批量检测名称
+ * @param {Array} names - 名称数组
+ * @param {string} type - 类型
+ * @returns {Array} 检测结果数组
+ */
+NamingDetector.prototype.checkNames = function (names, type) {
+  if (!Array.isArray(names)) {
+    throw new TypeError('名称必须是数组');
+  }
+
+  return names.map(name => this.check_name(name, type));
+}
+
+/**
+ * ESLint规则实现
+ */
+
+/**
+ * 类名大驼峰规则
+ */
+const classNameRule = {
+  meta: {
+    type: 'suggestion',
+    docs: {
+      description: '类名必须使用大驼峰命名法（PascalCase）且优先使用单个单词',
+      category: 'Stylistic Issues',
+      recommended: true
+    },
+    schema: [
+      {
+        type: 'object',
+        properties: {
+          regex: { type: 'string' },
+          min: { type: 'number' },
+          max: { type: 'number' },
+          message: { type: 'string' },
+          single_word_preferred: { type: 'boolean' }
+        },
+        additionalProperties: false
+      }
+    ]
+  },
+  create(context) {
+    const options = context.options[0] || {};
+    return {
+      ClassDeclaration(node) {
+        const class_name = node.id.name;
+        const detector = new NamingDetector({ 'class-name': options });
+        const result = detector.checkName(class_name, 'class-name');
+
+        if (!result.valid) {
+          result.errors.forEach(error => {
+            context.report({
+              node: node.id,
+              message: `类名"${class_name}"不符合规范: ${error}`
+            });
+          });
+        }
+      }
+    };
+  }
+};
+
+/**
+ * 函数名小驼峰规则
+ */
+const functionNameRule = {
+  meta: {
+    type: 'suggestion',
+    docs: {
+      description: '函数名必须使用小驼峰命名法（camelCase）且优先使用单个单词',
+      category: 'Stylistic Issues',
+      recommended: true
+    },
+    schema: [
+      {
+        type: 'object',
+        properties: {
+          regex: { type: 'string' },
+          min: { type: 'number' },
+          max: { type: 'number' },
+          message: { type: 'string' },
+          single_word_preferred: { type: 'boolean' }
+        },
+        additionalProperties: false
+      }
+    ]
+  },
+  create(context) {
+    const options = context.options[0] || {};
+    return {
+      FunctionDeclaration(node) {
+        const function_name = node.id ? node.id.name : 'anonymous';
+        if (function_name !== 'anonymous') {
+          const detector = new NamingDetector({ 'function-name': options });
+          const result = detector.checkName(function_name, 'function-name');
+
+          if (!result.valid) {
+            result.errors.forEach(error => {
+              context.report({
+                node: node.id,
+                message: `函数名"${function_name}"不符合规范: ${error}`
+              });
+            });
+          }
+        }
+      },
+
+      FunctionExpression(node) {
+        if (node.id) {
+          const function_name = node.id.name;
+          const detector = new NamingDetector({ 'function-name': options });
+          const result = detector.checkName(function_name, 'function-name');
+
+          if (!result.valid) {
+            result.errors.forEach(error => {
+              context.report({
+                node: node.id,
+                message: `函数表达式名"${function_name}"不符合规范: ${error}`
+              });
+            });
+          }
+        }
+      }
+    };
+  }
+};
+
+/**
+ * 方法名小驼峰规则
+ */
+const methodNameRule = {
+  meta: {
+    type: 'suggestion',
+    docs: {
+      description: '方法名必须使用小驼峰命名法（camelCase）且优先使用单个单词',
+      category: 'Stylistic Issues',
+      recommended: true
+    },
+    schema: [
+      {
+        type: 'object',
+        properties: {
+          regex: { type: 'string' },
+          min: { type: 'number' },
+          max: { type: 'number' },
+          message: { type: 'string' },
+          single_word_preferred: { type: 'boolean' }
+        },
+        additionalProperties: false
+      }
+    ]
+  },
+  create(context) {
+    const options = context.options[0] || {};
+    return {
+      MethodDefinition(node) {
+        const method_name = node.key.name;
+        const detector = new NamingDetector({ 'method-name': options });
+        const result = detector.checkName(method_name, 'method-name');
+
+        if (!result.valid) {
+          result.errors.forEach(error => {
+            context.report({
+              node: node.key,
+              message: `方法名"${method_name}"不符合规范: ${error}`
+            });
+          });
+        }
+      }
+    };
+  }
+};
+
+/**
+ * 变量名小写蛇形规则
+ */
+const variableNameRule = {
+  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_preferred: { type: 'boolean' }
+        },
+        additionalProperties: false
+      }
+    ]
+  },
+  create(context) {
+    const options = context.options[0] || {};
+    return {
+      VariableDeclarator(node) {
+        if (node.id.type === 'Identifier') {
+          const variable_name = node.id.name;
+          const detector = new NamingDetector({ 'variable-name': options });
+          const result = detector.checkName(variable_name, 'variable-name');
+
+          if (!result.valid) {
+            result.errors.forEach(error => {
+              context.report({
+                node: node.id,
+                message: `变量名"${variable_name}"不符合规范: ${error}`
+              });
+            });
+          }
+        }
+      }
+    };
+  }
+};
+
+/**
+ * 常量名大写蛇形规则
+ */
+const constantNameRule = {
+  meta: {
+    type: 'suggestion',
+    docs: {
+      description: '常量名必须使用大写蛇形命名法（UPPER_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_preferred: { type: 'boolean' }
+        },
+        additionalProperties: false
+      }
+    ]
+  },
+  create(context) {
+    const options = context.options[0] || {};
+    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 (!result.valid) {
+            result.errors.forEach(error => {
+              context.report({
+                node: node.id,
+                message: `常量名"${constant_name}"不符合规范: ${error}`
+              });
+            });
+          }
+        }
+      }
+    };
+  }
+};
+
+/**
+ * 私有成员命名规则
+ */
+const privateNamingRule = {
+  meta: {
+    type: 'suggestion',
+    docs: {
+      description: '私有成员必须以单下划线开头，后跟小写蛇形命名',
+      category: 'Stylistic Issues',
+      recommended: true
+    },
+    schema: [
+      {
+        type: 'object',
+        properties: {
+          regex: { type: 'string' },
+          min: { type: 'number' },
+          max: { type: 'number' },
+          message: { type: 'string' },
+          single_word_preferred: { type: 'boolean' }
+        },
+        additionalProperties: false
+      }
+    ]
+  },
+  create(context) {
+    const options = context.options[0] || {};
+    return {
+      MethodDefinition(node) {
+        const method_name = node.key.name;
+        if (method_name.startsWith('_')) {
+          const detector = new NamingDetector({ 'private-naming': options });
+          const result = detector.checkName(method_name, 'private-naming');
+
+          if (!result.valid) {
+            result.errors.forEach(error => {
+              context.report({
+                node: node.key,
+                message: `私有方法名"${method_name}"不符合规范: ${error}`
+              });
+            });
+          }
+        }
+      },
+
+      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 result = detector.checkName(private_name, 'private-naming');
+
+          if (!result.valid) {
+            result.errors.forEach(error => {
+              context.report({
+                node: node.key,
+                message: `私有属性名"${private_name}"不符合规范: ${error}`
+              });
+            });
+          }
+        }
+      }
+    };
+  }
+};
+
+/**
+ * 命名规范ESLint插件
+ */
+const namingRules = {
+  'class-name': classNameRule,
+  'function-name': functionNameRule,
+  'method-name': methodNameRule,
+  'variable-name': variableNameRule,
+  'constant-name': constantNameRule,
+  'private-naming': privateNamingRule
+};
+
+module.exports = {
+  NamingDetector,
+  rules: namingRules
+};

package/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "mm_eslint",
+  "version": "1.0.1",
+  "description": "ESLint plugin for naming conventions - PascalCase, camelCase, snake_case, and UPPER_SNAKE_CASE naming rules",
+  "main": "index.js",
+  "keywords": [
+    "eslint",
+    "eslintplugin",
+    "eslint-plugin",
+    "naming-convention",
+    "naming-rules",
+    "coding-standards",
+    "pascalcase",
+    "camelcase",
+    "snake-case",
+    "code-quality"
+  ],
+  "author": "qww",
+  "license": "ISC",
+  "repository": {
+    "type": "git",
+    "url": "https://gitee.com/qiuwenwu91/mm_eslint.git"
+  },
+  "homepage": "https://gitee.com/qiuwenwu91/mm_eslint",
+  "bugs": {
+    "url": "https://gitee.com/qiuwenwu91/mm_eslint/issues"
+  },
+  "engines": {
+    "node": ">=12.0.0"
+  },
+  "peerDependencies": {
+    "eslint": ">=8.0.0"
+  },
+  "scripts": {
+    "test": "node test.js",
+    "lint": "npx eslint . --config eslint.config.js"
+  },
+  "files": [
+    "index.js",
+    "README.md",
+    "README_EN.md",
+    "LICENSE"
+  ]
+}