mm_eslint 1.4.3 → 1.4.5

package/package.json

@@ -1,49 +1,59 @@
-{
-  "name": "mm_eslint",
-  "version": "1.4.3",
-  "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 tests/test_basic.js",
-    "lint": "npx eslint . --config eslint.config.js"
-  },
-  "files": [
-    "index.js",
-    "detector.js",
-    "config.js",
-    "README.md",
-    "README_EN.md",
-    "LICENSE"
-  ],
-  "devDependencies": {
-    "eslint-plugin-jsdoc": "^61.5.0"
-  }
-}
+{
+  "name": "mm_eslint",
+  "version": "1.4.5",
+  "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_module_integration.js",
+    "lint": "npx eslint . --config eslint.config.js"
+  },
+  "files": [
+    "config.js",
+    "corrector.js",
+    "detector.js",
+    "eslint.config.js",
+    "fix.js",
+    "handler.js",
+    "index.js",
+    "tip.js",
+    "util.js",
+    "validator.js",
+    "README.md",
+    "README_EN.md",
+    "LICENSE"
+  ],
+  "devDependencies": {
+    "eslint-plugin-jsdoc": "^61.5.0"
+  },
+  "dependencies": {
+    "@babel/parser": "^7.28.6"
+  }
+}

package/tip.js

@@ -0,0 +1,85 @@
+var { Config } = require('./config');
+var { Corrector } = require('./corrector');
+var corrector = new Corrector();
+
+/**
+ * 提示管理类
+ * 统一管理所有错误提示和建议使用词的生成
+ */
+class Tip {
+  /**
+   * 构造函数
+   * @param {object} config 配置对象
+   */
+  constructor(config) {
+    this.config = config || new Config();
+  }
+}
+
+/**
+ * 生成完整的错误提示
+ * @param {object} error 错误信息
+ * @param {string} fix_suggestion 修正建议
+ * @returns {string} 完整的错误提示
+ */
+Tip.prototype.getFullMessage = function(error, fix_suggestion) {
+  var base_message = this._getBaseMessage(error);
+  var suggestion = fix_suggestion || corrector.getSuggestion(error);
+  if (suggestion) {
+    return base_message + '，建议使用：' + suggestion;
+  }
+
+  return base_message;
+};
+
+/**
+ * 获取声明方式问题的错误消息
+ * @param {string} issue_type 问题类型
+ * @param {string} name 名称
+ * @returns {string} 错误消息
+ */
+Tip.prototype.getDeclarationIssueMessage = function(issue_type, name) {
+  switch (issue_type) {
+    case 'const-should-be-let':
+      return `变量'${name}'应该用let声明而不是const`;
+    default:
+      return `变量'${name}'声明方式不符合规范`;
+  }
+};
+
+/**
+ * 获取基础错误消息
+ * @param {object} error 错误信息对象
+ * @returns {string} 基础错误消息
+ */
+Tip.prototype._getBaseMessage = function(error) {
+  var type_name_map = this.config.getTypeNameMap();
+  var name = error.name;
+  var original_type = error.original_type || 'variable';
+  var type_name = type_name_map[original_type] || '名称';
+
+  switch (error.type) {
+    case 'style':
+      var styles = error.rule.styles.join('、');
+      return `${type_name}'${name}'命名不符合${styles}风格`;
+
+    case 'length':
+      if (error.min_length) {
+        return `${type_name}'${name}'小于最小长度${error.min_length}字符`;
+      } else {
+        return `${type_name}'${name}'超过最大长度${error.max_length}字符`;
+      }
+
+    case 'word_length':
+      var word = error.word || name;
+      return `${type_name}'${name}'拼接单词"${word}"超过最大长度${error.max_word_length}字符`;
+
+    case 'forbidden_word':
+      return `${type_name}'${name}'拼接了禁用词"${error.forbidden_word}"`;
+
+    default:
+      return `${type_name}'${name}'不符合命名规范`;
+  }
+};
+
+module.exports = { Tip };

package/util.js

@@ -0,0 +1,241 @@
+
+module.exports = {
+  /**
+   * 分割单词
+   * @param {string} name 名称
+   * @returns {array} 单词数组
+   */
+  splitWords(name) {
+    if (!name || name.length === 0) {
+      return [];
+    }
+    
+    var words = [];
+    var current_word = '';
+    var last_char_type = null; // 'upper', 'lower', 'underscore', 'digit', 'other'
+    
+    for (var i = 0; i < name.length; i++) {
+      var char = name[i];
+      var is_upper = char >= 'A' && char <= 'Z';
+      var is_lower = char >= 'a' && char <= 'z';
+      var is_digit = char >= '0' && char <= '9';
+      var is_underscore = char === '_';
+      
+      // 处理下划线和数字：直接作为单词分隔符
+      if (is_underscore || is_digit) {
+        if (current_word.length > 0) {
+          words.push(current_word);
+          current_word = '';
+        }
+        if (is_digit) {
+          // 数字作为独立的单词
+          words.push(char);
+          last_char_type = 'digit';
+        } else {
+          last_char_type = 'underscore';
+        }
+        continue;
+      }
+      
+      // 处理第一个字符
+      if (current_word.length === 0) {
+        current_word = char;
+        if (is_upper) {
+          last_char_type = 'upper';
+        } else if (is_lower) {
+          last_char_type = 'lower';
+        } else if (is_digit) {
+          last_char_type = 'digit';
+        } else {
+          last_char_type = 'other';
+        }
+        continue;
+      }
+      
+      // 判断当前字符类型
+      var current_char_type;
+      if (is_upper) {
+        current_char_type = 'upper';
+      } else if (is_lower) {
+        current_char_type = 'lower';
+      } else if (is_digit) {
+        current_char_type = 'digit';
+      } else {
+        current_char_type = 'other';
+      }
+      
+      // 大小写转换逻辑（仅对字母字符有效）
+      if ((last_char_type === 'upper' || last_char_type === 'lower') && 
+          (current_char_type === 'upper' || current_char_type === 'lower')) {
+        
+        if (last_char_type === 'upper' && current_char_type === 'lower') {
+          // 大写转小写：将上一个词组的最后一个字符作为下一个词的开头
+          if (current_word.length > 1) {
+            var last_char = current_word[current_word.length - 1];
+            words.push(current_word.substring(0, current_word.length - 1));
+            current_word = last_char + char;
+          } else {
+            current_word += char;
+          }
+        } else if (last_char_type === 'lower' && current_char_type === 'upper') {
+          // 小写转大写：大写开头就是下个单词的开头
+          words.push(current_word);
+          current_word = char;
+        } else {
+          // 相同类型字符，继续当前单词
+          current_word += char;
+        }
+      } else {
+        // 数字或其他字符，直接添加到当前单词
+        current_word += char;
+      }
+      
+      last_char_type = current_char_type;
+    }
+    
+    // 添加最后一个单词
+    if (current_word.length > 0) {
+      words.push(current_word);
+    }
+    
+    return words;
+  },
+  
+  /**
+   * 获取实际名称和前缀
+   * @param {string} name 名称
+   * @returns {object} 包含前缀和实际名称的对象
+   */
+  getRealName(name) {
+    var real_name = name;
+    var prefix = '';
+    if (real_name.indexOf('_') === 0) {
+      prefix = '_';
+      real_name = real_name.replace('_', '');
+    }
+    else if (real_name.indexOf('#') === 0) {
+      prefix = '#';
+      real_name = real_name.replace('#', '');
+    }
+    return {
+      prefix,
+      real_name
+    };
+  }
+}
+
+/**
+ * 智能驼峰分割函数（外部使用）
+ * @param {string} name 名称
+ * @param {array} common_abbreviations 常见缩写词字典
+ * @returns {array} 分割后的单词数组
+ */
+function _smartSplitCamelCase(name, common_abbreviations) {
+  // 智能分割：结合下划线分割和驼峰分割
+  // 先按下划线分割
+  var underscore_words = name.split('_').filter(function (word) { return word.length > 0; });
+  
+  // 对每个下划线分割后的单词，再进行驼峰分割
+  var final_words = [];
+  underscore_words.forEach(function (word) {
+    // 如果是单个字母，直接添加
+    if (word.length === 1) {
+      final_words.push(word);
+      return;
+    }
+    
+    // 智能驼峰分割：识别连续大写字母和常见缩写词
+    var camel_words = [];
+    var current_word = '';
+    var last_char_was_upper = false;
+    
+    for (var i = 0; i < word.length; i++) {
+      var char = word[i];
+      var is_upper = char >= 'A' && char <= 'Z';
+      
+      // 如果是大写字母
+      if (is_upper) {
+        // 如果上一个字符也是大写，继续当前单词（缩写词）
+        if (last_char_was_upper) {
+          current_word += char;
+        } else {
+          // 如果当前单词不为空，先保存
+          if (current_word.length > 0) {
+            camel_words.push(current_word);
+          }
+          current_word = char;
+        }
+        last_char_was_upper = true;
+      } else {
+        // 如果是小写字母
+        // 如果上一个字符是大写且当前单词长度>1，说明是缩写词结束
+        if (last_char_was_upper && current_word.length > 1) {
+          camel_words.push(current_word);
+          current_word = char;
+        } else {
+          current_word += char;
+        }
+        last_char_was_upper = false;
+      }
+    }
+    
+    // 添加最后一个单词
+    if (current_word.length > 0) {
+      camel_words.push(current_word);
+    }
+    
+    // 后处理：合并已知的常见缩写词
+    var processed_words = [];
+    var i = 0;
+    while (i < camel_words.length) {
+      var current = camel_words[i];
+      
+      // 检查是否是常见缩写词
+      var found_abbr = false;
+      for (var j = common_abbreviations.length - 1; j >= 0; j--) {
+        var abbr = common_abbreviations[j];
+        if (current.toUpperCase() === abbr) {
+          processed_words.push(abbr);
+          found_abbr = true;
+          break;
+        }
+      }
+      
+      if (found_abbr) {
+        i++;
+        continue;
+      }
+      
+      // 尝试合并连续的单个大写字母（可能是缩写词的一部分）
+      if (current.length === 1 && /[A-Z]/.test(current)) {
+        var combined = current;
+        var k = i + 1;
+        while (k < camel_words.length && camel_words[k].length === 1 && /[A-Z]/.test(camel_words[k])) {
+          combined += camel_words[k];
+          k++;
+        }
+        
+        // 检查合并后的结果是否是常见缩写词
+        var is_known_abbr = common_abbreviations.includes(combined);
+        if (is_known_abbr) {
+          processed_words.push(combined);
+          i = k;
+        } else {
+          // 如果不是已知缩写词，保持原样
+          processed_words.push(current);
+          i++;
+        }
+      } else {
+        processed_words.push(current);
+        i++;
+      }
+    }
+    
+    // 如果有多个单词，分别添加
+    processed_words.forEach(function (w) {
+      final_words.push(w);
+    });
+  });
+  
+  return final_words;
+}

package/validator.js

@@ -0,0 +1,266 @@
+const { Config } = require('./config');
+const { splitWords, getRealName } = require('./util');
+
+/**
+ * 命名规范验证器类
+ * 负责验证命名是否符合规范
+ */
+class Validator {
+  /**
+   * 构造函数
+   * @param {object} config 配置对象
+   */
+  constructor(config) {
+    this.config = config || new Config();
+  }
+}
+
+/**
+ * 验证命名是否符合规范
+ * @param {string} name 名称
+ * @param {string} original_type 原始类型
+ * @returns {object|null} 错误信息对象或null
+ */
+Validator.prototype.validate = function (name, original_type) {
+  // 获取命名规则
+  var name_type = this._getValidationType(original_type);
+  // 获取命名规则
+  var rule = this.config.getRule(name_type);
+  // 如果没有配置规则，直接返回null
+  if (!rule) {
+    return null
+  }
+  var {
+    prefix,
+    real_name
+  } = getRealName(name);
+  var words = splitWords(real_name);
+  var error = this.check(real_name, words, rule);
+  if (error) {
+    error.name = name;
+    error.prefix = prefix;
+    error.real_name = real_name;
+    error.name_type = name_type;
+    error.original_type = original_type;
+    error.words = words;
+    error.rule = rule;
+  }
+  return error;
+};
+
+/**
+ * 检查命名是否符合规范
+ * @param {string} name 名称
+ * @param {string} name_type 名称类型
+ * @returns {object|null} 错误信息对象或null
+ */
+Validator.prototype.check = function (name, words, rule) {
+  try {
+    // 如果是忽略检测的词，直接返回null
+    var is_ignore = this._isIgnoreWord(name, rule.ignore_words);
+    if (is_ignore) {
+      return null;
+    }
+
+    // 检查命名风格，最重要，错误级。
+    var style_error = this._validateNamingStyle(name, rule.styles);
+    if (style_error) {
+      return style_error;
+    }
+
+    // 检查名称长度，其次，警告级。
+    var length_error = this._validateLength(name, rule.min, rule.max);
+    if (length_error) {
+      return length_error;
+    }
+    if (!rule.single_word || words.length < 2) {
+      return null;
+    }
+
+    // 检查禁止拼接词，警告级。
+    var forbidden_error = this._validateForbiddenWords(words, rule.forbidden_words);
+    if (forbidden_error) {
+      return forbidden_error;
+    }
+
+    // 检查每个单词的长度, 警告级。
+    var word_error = this._validateWordLength(words, rule.single_word_len);
+    if (word_error) {
+      return word_error;
+    }
+
+    return null;
+  } catch (error) {
+    // 验证过程中出现异常，返回null
+    return null;
+  }
+}
+
+/**
+ * 判断名称是否为忽略词
+ * @param {string} name 名称
+ * @param {array} ignore_words 忽略词数组
+ * @returns {boolean} 是否为忽略词
+ */
+Validator.prototype._isIgnoreWord = function (name, ignore_words) {
+  if (!ignore_words || ignore_words.length === 0) {
+    return false;
+  }
+  for (var i = 0; i < ignore_words.length; i++) {
+    var ignore_word = ignore_words[i];
+    if (ignore_word.toLowerCase() === name.toLowerCase()) {
+      return true;
+    }
+  }
+  return false;
+};
+
+/**
+ * 验证名称长度
+ * @param {string} name 名称
+ * @param {number} min 最小长度
+ * @param {number} max 最大长度
+ * @returns {object|null} 错误信息或null
+ */
+Validator.prototype._validateLength = function (name, min = 1, max = 32) {
+  if (!name || name.length === 0) {
+    return null;
+  }
+  var name_length = name.length;
+  if (name_length < min) {
+    return {
+      type: 'length',
+      severity: 'warning',
+      name_length,
+      min_length: min
+    };
+  }
+  if (name_length > max) {
+    return {
+      type: 'length',
+      severity: 'warning',
+      name_length,
+      max_length: max
+    };
+  }
+  return null;
+};
+
+/**
+ * 获取验证类型
+ * @param {string} original_type 原始类型
+ * @returns {string} 验证类型
+ */
+Validator.prototype._getValidationType = function (original_type) {
+  return original_type.replace('property-', '').replace('static-', '').replace('prototype-', '').replace('private-', '').replace('internal-', '').replace('use-', '').replace('param-', '');
+};
+
+/**
+ * 验证命名风格
+ * @param {string} name 名称
+ * @param {object} styles 规则配置
+ * @returns {object|null} 错误信息或null
+ */
+Validator.prototype._validateNamingStyle = function (name, styles) {
+  if (!styles || styles.length === 0) {
+    return null;
+  }
+  // 检查是否匹配任一允许的风格
+  var is_valid = styles.some((style) => {
+    return this.isValidStyle(name, style);
+  }, this);
+
+  if (!is_valid) {
+    return {
+      type: 'style',
+      severity: 'error',
+      style: styles[0]
+    };
+  }
+
+  return null;
+};
+
+/**
+ * 验证单词长度
+ * @param {array} words 单词数组
+ * @param {number} single_word_len 单个单词最大长度
+ * @returns {object|null} 错误信息或null
+ */
+Validator.prototype._validateWordLength = function (words, single_word_len = 16) {
+  if (!words || words.length === 0) {
+    return null;
+  }
+  // 检查每个单词的长度
+  for (var i = 0; i < words.length; i++) {
+    var word = words[i];
+    if (word.length > single_word_len) {
+      return {
+        type: 'word_length',
+        severity: 'warning',
+        word: word,
+        word_length: word.length,
+        max_word_length: single_word_len
+      };
+    }
+  }
+
+  return null;
+};
+
+/**
+ * 验证禁止拼接词
+ * @param {array} words 单词数组
+ * @param {array} forbidden_words 禁止拼接词数组
+ * @returns {object|null} 错误信息或null
+ */
+Validator.prototype._validateForbiddenWords = function (words, forbidden_words) {
+  if (!forbidden_words || forbidden_words.length === 0) {
+    return null;
+  }
+
+  for (var i = 0; i < words.length; i++) {
+    let word = this.getForbiddenWord(forbidden_words, words[i]);
+    if (word) {
+      return {
+        type: 'forbidden_word',
+        severity: 'warning',
+        forbidden_word: word
+      };
+    }
+  }
+  return null;
+};
+
+/**
+ * 检查单词数组是否包含禁止拼接词
+ * @param {array} forbidden_words 禁止拼接词组
+ * @param {string} word 单词
+ * @returns {boolean} 是否包含禁止拼接词
+ */
+Validator.prototype.getForbiddenWord = function (forbidden_words, word) {
+  let word_lower = word.toLowerCase();
+  for (var i = 0; i < forbidden_words.length; i++) {
+    // 忽略大小写进行比较
+    if (forbidden_words[i].toLowerCase() === word_lower) {
+      return word;
+    }
+  }
+  return null;
+};
+
+/**
+ * 检查名称是否匹配指定风格
+ * @param {string} name 名称
+ * @param {string} style 命名风格
+ * @returns {boolean} 是否匹配
+ */
+Validator.prototype.isValidStyle = function (name, style) {
+  if (!name || name.length === 0) {
+    return false;
+  }
+  var regex = this.config.getRegex(style);
+  return regex ? regex.test(name) : false;
+};
+
+module.exports = { Validator };