mm_eslint 1.4.4 → 1.4.6

package/{config.js → lib/config.js}

@@ -15,6 +15,7 @@ class Config {
         'class-instance': [],
         'function': [],
         'param': [],
+        'object': [],
         'variable': [],
         'constant': []
       },
@@ -24,6 +25,7 @@ class Config {
         'class-instance': [],
         'function': [],
         'param': [],
+        'object': [],
         'variable': [],
         'constant': []
       },
@@ -33,6 +35,7 @@ class Config {
         'class-instance': {},
         'function': {},
         'param': {},
+        'object': {},
         'variable': {},
         'constant': {}
       }
@@ -47,8 +50,8 @@ class Config {
  */
 Config.prototype.getRegex = function (style) {
   var regex = {
-    "PascalCase": /^[A-Z][a-z]*([A-Z][a-z]*)*$/,
-    "camelCase": /^[a-z][a-z]*([A-Z][a-z]*)*$/,
+    "PascalCase": /^[A-Z][a-z]+[A-Za-z]*$/,
+    "camelCase": /^[a-z][a-z]*([A-Z][a-z]*)*[a-z0-9]*$/,
     "snake_case": /^[a-z][a-z0-9]*(_[a-z0-9]+)*$/,
     "UPPER_SNAKE_CASE": /^[A-Z][A-Z0-9]*(_[A-Z0-9]+)*$/,
     "lowercase": /^[a-z]+([a-z0-9]+)*$/,
@@ -65,7 +68,7 @@ Config.prototype.getRegex = function (style) {
  * @returns {Array} 禁止拼接词列表
  */
 Config.prototype.getForbiddenWords = function (name_type) {
-  let type = name_type.replace('property-', '').replace('instance-', '');
+  let type = this.getType(name_type);
   var forbidden = {
     'class': [
       'manager',
@@ -103,6 +106,7 @@ Config.prototype.getForbiddenWords = function (name_type) {
       'field',
       'property',
       'entity',
+      'data'
     ],
     'function': [
       'data',
@@ -149,10 +153,10 @@ Config.prototype.getForbiddenWords = function (name_type) {
       'array',
       'map',
       'set',
-      'collection',
       'container',
       'instance',
       'data',
+      'collection',
       'item',
       'items',
       'element',
@@ -300,6 +304,14 @@ Config.prototype.getBaseRule = function (name_type) {
       single_word: true,
       single_word_len: 8
     },
+    'object': {
+      name: '对象名',
+      min: 1,
+      max: 20,
+      styles: ['camelCase', 'snake_case'],
+      single_word: true,
+      single_word_len: 8
+    },
     'variable': {
       name: '变量名',
       min: 1,
@@ -308,6 +320,14 @@ Config.prototype.getBaseRule = function (name_type) {
       single_word: true,
       single_word_len: 8
     },
+    'property': {
+      name: '属性名',
+      min: 1,
+      max: 20,
+      styles: ['snake_case', 'camelCase', 'PascalCase'],
+      single_word: true,
+      single_word_len: 8
+    },
     'constant': {
       name: '常量名',
       min: 1,
@@ -341,13 +361,7 @@ Config.prototype.getRule = function (name_type) {
  * @returns {object} 推荐词映射
  */
 Config.prototype.getRecommendWords = function (name_type) {
-  let type = name_type.replace('property-', '').replace('instance-', '');
-  if (type == 'function') {
-    type = 'function';
-  }
-  else if (type == 'value') {
-    type = 'variable';
-  }
+  let type = this.getType(name_type);
   var recommend = {
     'class': {
       'App': ['Application'],
@@ -460,17 +474,33 @@ Config.prototype.getRecommendWords = function (name_type) {
   return {};
 };
 
+Config.prototype.getType = function (name_type) {
+  let type = name_type.replace('property-', '').replace('internal-', '').replace('private-', '').replace('internal-', '').replace('prototype-', '').replace('use-', '').replace('super-', '').replace('static-', '').replace('param-', '').replace('export-', '');
+  return type;
+}
+
 /**
  * 获取忽略词列表
  * @param {string} name_type 名称类型
  * @returns {Array} 忽略词列表
  */
 Config.prototype.getIgnoreWords = function (name_type) {
-  let type = name_type.replace('property-', '').replace('instance-', '');
+  let type = this.getType(name_type);
   var ignore = {
     'class': [
       'exports', 'Middleware', 'Component', 'Controller', 'Repository', 'Interface', 'Transformer', 'Template'
     ],
+    'class-instance': [
+      // JavaScript 内置全局对象（只保留不符合小驼峰规范的）
+      'JSON', 'Math', 'RegExp', 'EvalError', 'RangeError', 'ReferenceError', 
+      'SyntaxError', 'TypeError', 'URIError', 'WeakMap', 'WeakSet', 'Promise', 
+      'Proxy', 'Reflect', 'Intl', 'ArrayBuffer', 'DataView', 'Float32Array', 'Float64Array',
+      'Int8Array', 'Int16Array', 'Int32Array', 'Uint8Array', 'Uint16Array', 'Uint32Array',
+      'Uint8ClampedArray', 'BigInt64Array', 'BigUint64Array', 'Atomics', 'SharedArrayBuffer',
+      'URL', 'URLSearchParams', 'Headers', 'Request', 'Response', 'FormData', 'Blob', 'File',
+      'FileReader', 'Image', 'Audio', 'Video', 'Canvas', 'WebSocket', 'EventSource',
+      'XMLHttpRequest', 'Infinity', 'NaN', 'global'
+    ],
     'function': [
       'constructor', 'prototype', 'hasOwnProperty',
       'isPrototypeOf', 'propertyIsEnumerable', 'toLocaleString',
@@ -531,27 +561,62 @@ Config.prototype.getTypeNameMap = function () {
     var type_name_map = {
     'function': '函数',
     'variable': '变量',
-    'param': '参数',
+    'object': '对象',
     'class-instance': '类实例',
     'class': '类',
     'constant': '常量',
-    'property-function': '属性函数',
-    'property-variable': '属性变量',
-    'property-class-instance': '属性类实例',
-    'property-class': '属性类',
-    'property-constant': '属性常量',
-    'static-function': '静态函数',
-    'static-variable': '静态变量',
-    'static-class-instance': '静态类实例',
-    'static-class': '静态类',
-    'static-constant': '静态常量',
-    'prototype-function': '原型函数',
-    'prototype-variable': '原型变量',
-    'prototype-class-instance': '原型类实例',
-    'prototype-class': '原型类',
-    'prototype-constant': '原型常量',
-    'private-function': '私有函数',
-    'private-variable': '私有变量'
+    'super-class': '继承-类',
+    // 属性
+    'property': '属性',
+    'property-function': '属性—函数',
+    'property-variable': '属性—变量',
+    'property-object': '属性—对象',
+    'property-class-instance': '属性—类实例',
+    'property-class': '属性—类',
+    'property-constant': '属性—常量',
+    // 静态属性
+    'static-function': '静态属性—函数',
+    'static-variable': '静态属性—变量',
+    'static-object': '静态属性—对象',
+    'static-class-instance': '静态属性—类实例',
+    'static-class': '静态属性—类',
+    'static-constant': '静态属性—常量',
+    // 原型属性
+    'prototype-class-instance': '原型属性—类实例',
+    'prototype-function': '原型属性—函数',
+    'prototype-variable': '原型属性—变量',
+    'prototype-object': '原型属性—对象',
+    // 私有属性
+    'private-function': '私有属性—函数',
+    'private-variable': '私有属性—变量',
+    'private-object': '私有属性—对象',
+    'private-class-instance': '私有属性—类实例',
+    // 内部属性
+    'internal-function': '内部属性—函数',
+    'internal-variable': '内部属性—变量',
+    'internal-object': '内部属性—对象',
+    'internal-class-instance': '内部属性—类实例',
+    // 引用
+    'use-variable': '引用-变量',
+    'use-function': '引用-函数',
+    'use-object': '引用-对象',
+    'use-class': '引用-类',
+    'use-constant': '引用-常量',
+    'use-class-instance': '引用-类实例',
+    // 参数
+    'param': '参数',
+    'param-class': '参数—类',
+    'param-class-instance': '参数—类实例',
+    'param-variable': '参数—变量',
+    'param-object': '参数—对象',
+    'param-function': '参数—函数',
+    // 导出
+    'export-class': '导出-类',
+    'export-class-instance': '导出-类实例',
+    'export-variable': '导出-变量',
+    'export-object': '导出-对象',
+    'export-function': '导出-函数',
+    'export-constant': '导出-常量'
   };
   return type_name_map;
 }

package/{corrector.js → lib/corrector.js}

@@ -43,7 +43,15 @@ Corrector.prototype.getSuggestion = function (error) {
   } catch {
     return error.name;
   }
-  return error.prefix + word;
+  
+  var suggestion = error.prefix + word;
+  
+  // 检查建议名称是否与原名称相同，如果相同则不显示建议
+  if (suggestion === error.name || word === error.name) {
+    return null;
+  }
+  
+  return suggestion;
 };
 
 /**
@@ -273,9 +281,54 @@ Corrector.prototype._filterForbiddenWord = function (words, forbidden_words) {
       new_word.push(word);
     }
   }
+  if (new_word.length === 0) {
+    new_word.push(words[words.length - 1]);
+  }
   return new_word;
 }
 
+/**
+ * 替换禁止词汇为推荐词汇
+ * @param {string[]} words 单词数组
+ * @param {Array} forbidden_words 禁止词列表
+ * @param {object} recommend_words 推荐词配置
+ * @returns {string[]} 替换后的单词数组
+ */
+Corrector.prototype._replaceForbiddenWords = function (words, forbidden_words, recommend_words) {
+  var new_words = [];
+  for (let i = 0; i < words.length; i++) {
+    let word = words[i];
+    if (this._isForbiddenWord(word, forbidden_words)) {
+      // 尝试为禁用词找到替代建议
+      var replacement = this._getForbiddenWordReplacement(word, recommend_words);
+      if (replacement) {
+        new_words.push(replacement);
+      }
+    } else {
+      new_words.push(word);
+    }
+  }
+  return new_words;
+}
+
+/**
+ * 获取禁用词的替代建议
+ * @param {string} forbidden_word 禁用词
+ * @param {object} recommend_words 推荐词配置
+ * @returns {string} 替代建议词
+ */
+Corrector.prototype._getForbiddenWordReplacement = function (forbidden_word, recommend_words) {
+  for (var replacement in recommend_words) {
+    var forbidden_list = recommend_words[replacement];
+    for (let i = 0; i < forbidden_list.length; i++) {
+      if (forbidden_word.toLowerCase() === forbidden_list[i].toLowerCase()) {
+        return replacement;
+      }
+    }
+  }
+  return null;
+}
+
 /**
  * 获取推荐的单词
  * @param {string[]} words 单词数组
@@ -284,7 +337,6 @@ Corrector.prototype._filterForbiddenWord = function (words, forbidden_words) {
  * @returns {string[]} 推荐的单词数组
  */
 Corrector.prototype._toRecommendWords = function (words, recommend, single_word_len) {
-  // console.log('推荐单词', words, recommend, single_word_len);
   let recommend_words = [];
   for (let i = 0; i < words.length; i++) {
     let word = words[i];

package/lib/detector/class_instance_name.js

@@ -0,0 +1,246 @@
+const { Name } = require('./name.js');
+
+/**
+ * 类实例名检测器类
+ * 负责检测类实例名是否符合命名规范
+ */
+class ClassInstanceName extends Name {
+  constructor(context, config) {
+    super(context, config);
+  }
+}
+
+/**
+ * 变量声明节点检测函数
+ * @param {Object} node - 变量声明节点
+ * @returns {Object|undefined} - 检测结果对象或undefined
+ */
+ClassInstanceName.prototype.VariableDeclaration = function (node) {
+  // 判断右边是否有 new 表达式
+  if (node.declarations[0].init && node.declarations[0].init.type === 'NewExpression') {
+    let name = node.declarations[0].id.name;
+    let original_type = 'class-instance';
+    let error = this.check(node.declarations[0].id, name, original_type);
+    this.report(node.declarations[0].id, error, original_type);
+    return error;
+  }
+
+  // 判断右边是否有正则表达式字面量（RegExp实例）
+  if (node.declarations[0].init && node.declarations[0].init.type === 'Literal' &&
+    node.declarations[0].init.regex) {
+    let name = node.declarations[0].id.name;
+    let original_type = 'class-instance';
+    let error = this.check(node.declarations[0].id, name, original_type);
+    this.report(node.declarations[0].id, error, original_type);
+    return error;
+  }
+
+  // 判断右边是否直接赋值类实例名
+  if (node.declarations[0].init && node.declarations[0].init.type === 'Identifier') {
+    // 根据右边值的类型决定左边变量的类型
+    let original_type = this._getOriginalType(node.declarations[0], 'VariableDeclaration');
+
+    // 如果右边是类实例，左边变量应该按照类实例的命名规范检测（小驼峰）
+    if (original_type === 'class-instance') {
+      let name = node.declarations[0].id.name;
+      let error = this.check(node.declarations[0].id, name, 'class-instance');
+      this.report(node.declarations[0].id, error, 'class-instance');
+      return error;
+    }
+  }
+}
+
+/**
+ * 属性节点检测函数
+ * @param {Object} node - 属性节点
+ * @returns {Object|undefined} - 检测结果对象或undefined
+ */
+ClassInstanceName.prototype.Property = function (node) {
+  // 判断右边是否有 new 表达式
+  if (node.value.type === 'NewExpression') {
+    let name = node.key.name;
+    let original_type = 'property-class-instance';
+    let error = this.check(node, name, original_type);
+    this.report(node, error, original_type);
+    return error;
+  }
+
+  // 判断右边是否直接定义为类实例名
+  if (node.value.type === 'Identifier') {
+    // 根据右边值的类型决定左边属性的类型
+    let original_type = this._getOriginalType(node, 'Property');
+
+    // 如果右边是类实例，左边属性应该按照类实例的命名规范检测（小驼峰）
+    if (original_type === 'class-instance') {
+      let name = node.key.name;
+      let error = this.check(node, name, 'property-class-instance');
+      this.report(node, error, 'property-class-instance');
+      return error;
+    }
+  }
+}
+
+/**
+ * 类属性定义节点检测函数
+ * @param {Object} node - 类属性定义节点
+ * @returns {Object|undefined} - 检测结果对象或undefined
+ */
+ClassInstanceName.prototype.PropertyDefinition = function (node) {
+  // 判断右边是否有 new 表达式
+  if (node.value && node.value.type === 'NewExpression') {
+    let name = node.key.name;
+    let original_type = 'property-class-instance';
+    if (node.static) {
+      original_type = 'static-class-instance';
+    }
+    else if (node.key.type === 'PrivateIdentifier') {
+      original_type = 'private-class-instance';
+    }
+    else if (name.startsWith('_')) {
+      original_type = 'internal-class-instance';
+    }
+    let error = this.check(node, name, original_type);
+    this.report(node, error, original_type);
+    return error;
+  }
+
+  // 判断右边是否直接定义为类实例名
+  if (node.value && node.value.type === 'Identifier') {
+    // 根据右边值的类型决定左边属性的类型
+    let original_type = this._getOriginalType(node, 'PropertyDefinition');
+
+    // 如果右边是类实例，左边属性应该按照类实例的命名规范检测（小驼峰）
+    if (original_type === 'class-instance') {
+      let name = node.key.name;
+      let original_type = 'property-class-instance';
+      if (node.static) {
+        original_type = 'static-class-instance';
+      }
+      else if (node.key.type === 'PrivateIdentifier') {
+        original_type = 'private-class-instance';
+      }
+      else if (name.startsWith('_')) {
+        original_type = 'internal-class-instance';
+      }
+      let error = this.check(node, name, original_type);
+      this.report(node, error, original_type);
+      return error;
+    }
+  }
+}
+
+/**
+ * 赋值表达式节点检测函数
+ * @param {Object} node - 赋值表达式节点
+ * @returns {Object|undefined} - 检测结果对象或undefined
+ */
+ClassInstanceName.prototype.AssignmentExpression = function (node) {
+  // 检测 exports 或 module.exports 赋值：exports.classInstance = classInstance;
+  // 排除右边是对象字面量的情况，交由Property检测器处理
+  if (node.operator === '=' && node.left && node.left.type === 'MemberExpression' &&
+    node.right && node.right.type !== 'ObjectExpression') {
+    // 检查左边是否为 exports 或 module.exports
+    let left_object = node.left.object;
+    let is_exports = false;
+
+    if (left_object.type === 'Identifier' && left_object.name === 'exports') {
+      is_exports = true;
+    } else if (left_object.type === 'MemberExpression' &&
+      left_object.object.type === 'Identifier' &&
+      left_object.object.name === 'module' &&
+      left_object.property.type === 'Identifier' &&
+      left_object.property.name === 'exports') {
+      is_exports = true;
+    }
+
+    if (is_exports && node.right && node.right.type === 'Identifier') {
+      // 先判断右边是否为类实例
+      let original_type = this._getOriginalType(node, 'AssignmentExpression');
+
+      // 如果右边是类实例，才检测左边的属性名
+      if (original_type === 'class-instance') {
+        let left_property = node.left.property;
+        if (left_property && left_property.type === 'Identifier') {
+          let name = left_property.name;
+          let error = this.check(left_property, name, 'property-class-instance');
+          this.report(left_property, error, 'property-class-instance');
+          return error;
+        }
+      }
+    }
+  }
+}
+
+/**
+ * 默认导出节点检测函数
+ * @param {Object} node - 默认导出节点
+ * @returns {Object|undefined} - 检测结果对象或undefined
+ */
+ClassInstanceName.prototype.ExportDefaultDeclaration = function (node) {
+  // 检测导出的类实例名
+  if (node.declaration && node.declaration.type === 'Identifier') {
+    let name = node.declaration.name;
+    let type = this._getOriginalType(node.declaration, 'ExportDefaultDeclaration');
+    if (type === 'class-instance') {
+      let original_type = 'export-class-instance';
+      let error = this.check(node.declaration, name, original_type);
+      this.report(node.declaration, error, original_type);
+      return error;
+    }
+  }
+}
+
+/**
+ * 命名导出节点检测函数
+ * @param {Object} node - 命名导出节点
+ * @returns {Object|undefined} - 检测结果对象或undefined
+ */
+ClassInstanceName.prototype.ExportNamedDeclaration = function (node) {
+  // 检测导出的类实例声明（如 export const myInstance = new ClassName()）
+  if (node.declaration && node.declaration.type === 'VariableDeclaration') {
+    for (let i = 0; i < node.declaration.declarations.length; i++) {
+      let declaration = node.declaration.declarations[i];
+      if (declaration.init && declaration.init.type === 'NewExpression') {
+        let name = declaration.id.name;
+        let error = this.check(node, name, 'export-class-instance');
+        this.report(node, error, 'export-class-instance');
+        return error;
+      }
+    }
+  }
+
+  // 检测命名导出的类实例引用
+  if (node.specifiers && node.specifiers.length > 0) {
+    for (let i = 0; i < node.specifiers.length; i++) {
+      let specifier = node.specifiers[i];
+
+      // 检测导出的标识符（避免重复检测）
+      // 优先检测 exported 属性，如果存在则使用它，否则使用 local 属性
+      let identifier_to_check = null;
+      let identifier_name = '';
+      
+      if (specifier.exported && specifier.exported.type === 'Identifier') {
+        identifier_to_check = specifier.exported;
+        identifier_name = specifier.exported.name;
+      } else if (specifier.local && specifier.local.type === 'Identifier') {
+        identifier_to_check = specifier.local;
+        identifier_name = specifier.local.name;
+      }
+      
+      // 只有当找到有效标识符时才进行检测
+      if (identifier_to_check) {
+        let original_type = this._getOriginalType(specifier, 'ExportSpecifier');
+
+        // 只有当导出的是类实例时才检测
+        if (original_type === 'class-instance') {
+          let error = this.check(identifier_to_check, identifier_name, 'export-class-instance');
+          this.report(identifier_to_check, error, 'export-class-instance');
+        }
+      }
+    }
+  }
+}
+
+module.exports = {
+  ClassInstanceName
+};