mm_eslint 1.2.6 → 1.2.8

package/README_EN.md

@@ -256,7 +256,7 @@ The plugin validates that each word in compound names does not exceed 8 characte
 
 You can customize rule parameters through configuration:
 
-```javascript
+````javascript
 // Custom configuration example
 const customConfig = {
   "class-name": {
@@ -303,28 +303,28 @@ module.exports = [
     },
   },
 ];
-```
+````
 
 ### Available Recommendations
 
 The plugin provides recommendations for common programming operations:
 
-| Original Word | Recommended Word | Description |
-|---------------|------------------|-------------|
-| `calculate` | `calc` | Mathematical operations |
-| `generate` | `gen` | Data generation |
-| `initialize` | `init` | Initialization operations |
-| `execute` | `exec` | Command execution |
-| `process` | `run` | Data processing |
-| `retrieve` | `load` | Data loading |
-| `persist` | `save` | Data storage |
-| `compare` | `cmp` | Comparison operations |
-| `duplicate` | `copy` | Data copying |
-| `transfer` | `move` | Data movement |
-| `convert` | `to` | Type conversion |
-| `verify` | `check` | Validation checks |
-| `construct` | `create` | Object creation |
-| `handle` | `run` | Event handling |
+| Original Word | Recommended Word | Description               |
+| ------------- | ---------------- | ------------------------- |
+| `calculate`   | `calc`           | Mathematical operations   |
+| `generate`    | `gen`            | Data generation           |
+| `initialize`  | `init`           | Initialization operations |
+| `execute`     | `exec`           | Command execution         |
+| `process`     | `run`            | Data processing           |
+| `retrieve`    | `load`           | Data loading              |
+| `persist`     | `save`           | Data storage              |
+| `compare`     | `cmp`            | Comparison operations     |
+| `duplicate`   | `copy`           | Data copying              |
+| `transfer`    | `move`           | Data movement             |
+| `convert`     | `to`             | Type conversion           |
+| `verify`      | `check`          | Validation checks         |
+| `construct`   | `create`         | Object creation           |
+| `handle`      | `run`            | Event handling            |
 
 ### Examples
 

package/config.js

@@ -0,0 +1,523 @@
+/**
+ * 命名规范检测配置类
+ */
+class Config {
+  /**
+   * 构造函数
+   * @param {object} config 配置对象
+   */
+  constructor(config) {
+    this.config = Object.assign({
+      // 忽略词
+      ignored_words: {
+        'class-name': [],
+        'method-name': [],
+        'variable-name': [],
+        'constant-name': []
+      },
+      // 禁止词
+      forbidden_words: {
+        'class-name': [],
+        'method-name': [],
+        'variable-name': [],
+        'constant-name': []
+      },
+      // 推荐词
+      recommended_words: {
+        'class-name': {
+        },
+        'method-name': {
+        },
+        'variable-name': {
+        },
+        'constant-name': {
+        }
+      }
+    }, config);
+  }
+}
+
+/**
+ * 获取命名风格的正则表达式
+ * @param {string} style 命名风格
+ * @returns {RegExp} 正则表达式
+ */
+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]*)*$/,
+    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]*$/,
+    UPPERCASE: /^[A-Z][A-Z0-9]*$/,
+    _camelCase: /^_[a-z][a-z0-9]*([A-Z][a-z0-9]*)*$/,
+    _snake_case: /^_[a-z][a-z0-9]*(_[a-z0-9]+)*$/,
+    _lowercase: /^_[a-z][a-z0-9]*$/,
+  };
+
+  return regex[style] || null;
+};
+
+/**
+ * 获取命名类型的规则配置
+ * @param {string} name_type 命名类型
+ * @returns {object} 规则配置对象
+ */
+Config.prototype.getRule = function (name_type) {
+  var rule = {
+    'class-name': {
+      name: '类名',
+      message:
+        '必须使用大驼峰命名法（PascalCase），长度{min}-{max}字符，且优先使用单个单词，每个单词不超过{word_len}字符',
+      min: 1,
+      max: 20,
+      styles: ['PascalCase'],
+      single_word: true,
+      single_word_len: 8,
+    },
+    'function-name': {
+      name: '函数名',
+      message:
+        '必须使用小驼峰命名法（camelCase），长度{min}-{max}字符，且优先使用单个单词，每个单词不超过{word_len}字符',
+      min: 1,
+      max: 20,
+      styles: ['camelCase'],
+      single_word: true,
+      single_word_len: 8,
+    },
+    'method-name': {
+      name: '方法名',
+      message:
+        '必须使用小驼峰命名法（camelCase），长度{min}-{max}字符，且优先使用单个单词，每个单词不超过{word_len}字符',
+      min: 1,
+      max: 20,
+      styles: ['camelCase'],
+      single_word: true,
+      single_word_len: 8
+    },
+    'variable-name': {
+      name: '变量名',
+      message:
+        '必须使用小写蛇形命名法（snake_case），长度{min}-{max}字符，且优先使用单个单词，每个单词不超过{word_len}字符',
+      min: 1,
+      max: 20,
+      styles: ['snake_case'],
+      single_word: true,
+      single_word_len: 8
+    },
+    'param-name': {
+      name: '参数名',
+      message:
+        '必须使用小写蛇形命名法（snake_case），长度{min}-{max}字符，且优先使用单个单词，每个单词不超过{word_len}字符',
+      min: 1,
+      max: 20,
+      styles: ['snake_case'],
+      single_word: true,
+      single_word_len: 8
+    },
+    'constant-name': {
+      name: '常量名',
+      message:
+        '必须使用大写蛇形命名法（UPPER_SNAKE_CASE），长度{min}-{max}字符，且优先使用单个单词，每个单词不超过{word_len}字符',
+      min: 1,
+      max: 20,
+      styles: ['UPPER_SNAKE_CASE'],
+      single_word: true,
+      single_word_len: 8
+    },
+    'property-class-name': {
+      name: '属性类名',
+      message:
+        '属性类必须使用大驼峰命名法（PascalCase），长度{min}-{max}字符，且优先使用单个单词，每个单词不超过{word_len}字符',
+      min: 1,
+      max: 20,
+      styles: ['PascalCase'],
+      single_word: true,
+      single_word_len: 8
+    },
+    'property-instance-class-name': {
+      name: '属性实例类名',
+      message:
+        '属性实例类必须使用小驼峰命名法（camelCase），长度{min}-{max}字符，且优先使用单个单词，每个单词不超过{word_len}字符',
+      min: 1,
+      max: 20,
+      styles: ['camelCase'],
+      single_word: true,
+      single_word_len: 8
+    },
+    'property-method-name': {
+      name: '属性方法名',
+      message:
+        '属性方法必须使用小驼峰命名法（camelCase），长度{min}-{max}字符，且优先使用单个单词，每个单词不超过{word_len}字符',
+      min: 1,
+      max: 20,
+      styles: ['camelCase'],
+      single_word: true,
+      single_word_len: 8
+    },
+    'property-value-name': {
+      name: '属性值名',
+      message:
+        '属性值必须使用小写蛇形命名法（snake_case），长度{min}-{max}字符，且优先使用单个单词，每个单词不超过{word_len}字符',
+      min: 1,
+      max: 20,
+      styles: ['snake_case'],
+      single_word: true,
+      single_word_len: 8
+    },
+    'property-flexible-name': {
+      name: '灵活属性名',
+      message:
+        '灵活属性名支持多种命名风格，长度{min}-{max}字符，且优先使用单个单词，每个单词不超过{word_len}字符',
+      min: 1,
+      max: 20,
+      styles: ['snake_case', 'UPPER_SNAKE_CASE', 'PascalCase', 'camelCase', '_snake_case', '_camelCase'],
+      single_word: true,
+      single_word_len: 8
+    }
+  };
+
+  return rule[name_type] || null;
+};
+
+/**
+ * 获取命名类型的禁止词列表
+ * @param {string} name_type 命名类型
+ * @returns {Array} 禁止词列表
+ */
+Config.prototype.getForbiddenWords = function (name_type) {
+  name_type = name_type.replace('property-', '').replace('instance-', '');
+  if (name_type == 'method-name') {
+    name_type = 'method-name';
+  }
+  var forbidden = {
+    'class-name': [
+      'manager',
+      'handler',
+      'processor',
+      'controller',
+      'service',
+      'provider',
+      'factory',
+      'builder',
+      'adapter',
+      'decorator',
+      'proxy',
+      'facade',
+      'mediator',
+      'observer',
+      'strategy',
+      'command',
+      'visitor',
+      'iterator',
+      'template',
+      'flyweight',
+      'memento',
+      'interpreter',
+      'model',
+      'view',
+      'route',
+      'router',
+      'component',
+      'widget',
+      'panel',
+      'dialog',
+      'window',
+      'form',
+      'field',
+      'property',
+      'entity',
+    ],
+    'method-name': [
+      'data',
+      'result',
+      'output',
+      'input',
+      'param',
+      'params',
+      'parameter',
+      'parameters',
+      'value',
+      'values',
+      'item',
+      'items',
+      'process',
+      'processor',
+      'provider',
+      'builder',
+      'adapter',
+      'decorator',
+      'proxy',
+      'facade',
+      'mediator',
+      'observer',
+      'strategy',
+      'command',
+      'visitor',
+      'iterator',
+      'template',
+      'flyweight',
+      'memento',
+      'interpreter',
+      'temp',
+      'tmp',
+      'temporary',
+      'cached',
+      'buffered',
+      'idx',
+      'counter',
+    ],
+    'variable-name': [
+      'object',
+      'array',
+      'map',
+      'set',
+      'collection',
+      'container',
+      'instance',
+      'data',
+      'item',
+      'items',
+      'element',
+      'elements',
+      'entry',
+      'entries',
+      'temp',
+      'tmp',
+      'temporary',
+      'cached',
+      'buffer',
+      'buffered',
+      'input',
+      'output',
+      'result',
+      'destination',
+      'index',
+      'idx',
+      'counter',
+      'length',
+      'total',
+      'sum',
+      'pointer',
+      'reference',
+      'ref',
+      'handle',
+      'handler',
+      'entity',
+      'column',
+      'property',
+      'attribute'
+    ],
+    'constant-name': [
+      'manager',
+      'handler',
+      'processor',
+      'controller',
+      'service',
+      'provider',
+      'factory',
+      'builder',
+      'adapter',
+      'decorator',
+      'proxy',
+      'facade',
+      'mediator',
+      'observer',
+      'strategy',
+      'command',
+      'visitor',
+      'iterator',
+      'template',
+      'flyweight',
+      'memento',
+      'interpreter',
+      'model',
+      'view',
+      'route',
+      'router',
+      'component',
+      'widget',
+      'panel',
+      'dialog',
+      'window',
+      'form',
+      'field',
+      'property',
+      'entity',
+      'data',
+      'result',
+      'output',
+      'input',
+      'temp',
+      'tmp',
+      'temporary',
+      'cached',
+      'buffer',
+      'buffered'
+    ]
+  };
+
+  // 优先返回配置中的禁用词，其次返回硬编码禁用词
+  var config = this.config.forbidden_words[name_type];
+  var hardcoded = forbidden[name_type];
+
+  // 如果配置中的禁用词为空数组，则使用硬编码禁用词
+  if (config && config.length > 0) {
+    return config;
+  } else if (hardcoded && hardcoded.length > 0) {
+    return hardcoded;
+  }
+
+  return [];
+};
+
+/**
+ * 获取推荐词映射
+ * @param {string} name_type 名称类型
+ * @returns {object} 推荐词映射
+ */
+Config.prototype.getRecommendedWords = function (name_type) {
+  name_type = name_type.replace('property-', '').replace('instance-', '');
+  if (name_type == 'method-name') {
+    name_type = 'method-name';
+  }
+  var recommend = {
+    'class-name': {
+      'App': ['Application'],
+      'Config': ['Configuration'],
+      'Env': ['Environment'],
+      'Init': ['Initialization'],
+      'Auth': ['Authentication'],
+      'Authz': ['Authorization'],
+      'Valid': ['Validation'],
+      'Serializer': ['Serialization'],
+      'Deserializer': ['Deserialization'],
+      'Transformer': ['Transformation'],
+      'Impl': ['Implementation'],
+      'Proc': ['Processor'],
+      'Dcr': ['Decorator'],
+      'Prov': ['Provider'],
+      'Facade': ['Facade'],
+      'Obs': ['Observer'],
+      'Strat': ['Strategy'],
+      'Mnt': ['Memento'],
+      'Intp': ['Interpreter'],
+      'Cmp': ['Component'],
+      'Info': ['Information'],
+      'Conn': ['Connection'],
+      'Ext': ['Extension'],
+      'Asst': ['Assistant'],
+      'WebSocket': ['Websocket']
+    },
+    'method-name': {
+      'get': ['fetch', 'retrieve', 'obtain', 'query'],
+      'set': ['assign', 'setting', 'update'],
+      'add': ['append', 'insert'],
+      'del': ['delete'],
+      'check': ['validate', 'verify'],
+      'calc': ['calculate', 'compute', 'evaluate'],
+      'init': ['initialize', 'initialization', 'prepare'],
+      'calc': ['calculate'],
+      'gen': ['generate'],
+      'exec': ['execute'],
+      'run': ['process', 'handle'],
+      'load': ['retrieve'],
+      'save': ['persist'],
+      'cmp': ['compare'],
+      'copy': ['duplicate'],
+      'move': ['transfer'],
+      'to': ['convert', 'transform', 'transformation'],
+      'check': ['verify', 'validate'],
+      'create': ['construct'],
+      'calc': ['compute', 'calculate'],
+      'avg': ['average'],
+      'zip': ['compress'],
+      'unzip': ['decompress'],
+      'App': ['Application'],
+      'config': ['configure', 'Configuration'],
+      'env': ['Environment'],
+      'auth': ['authorize', 'Authentication'],
+      'authz': ['Authorization'],
+      'valid': ['Validation'],
+      'stringify': ['serialize', 'serialization'],
+      'parse': ['deserialize', 'deserialization'],
+      'impl': ['Implementation'],
+      'info': ['Information'],
+      'conn': ['Connection']
+    },
+    'variable-name': {
+      'obj': ['object'],
+      'arr': ['array'],
+      'str': ['string'],
+      'num': ['number'],
+      'bool': ['boolean'],
+      'fn': ['function'],
+      'tmp': ['temporary'],
+      'def': ['default'],
+      'max': ['maximum'],
+      'min': ['minimum'],
+      'avg': ['average']
+    },
+    'constant-name': {
+      'MAX': ['Maximum'],
+      'MIN': ['Minimum'],
+      'AVG': ['Average']
+    }
+  };
+
+  // 优先返回配置中的推荐词，其次返回硬编码推荐词
+  var config = this.config.recommended_words[name_type];
+  var hardcoded = recommend[name_type];
+
+  // 如果配置中的推荐词不为空对象，则使用配置推荐词
+  if (config && Object.keys(config).length > 0) {
+    return config;
+  } else if (hardcoded && Object.keys(hardcoded).length > 0) {
+    return hardcoded;
+  }
+
+  return {};
+};
+
+/**
+ * 获取忽略词列表
+ * @param {string} name_type 名称类型
+ * @returns {Array} 忽略词列表
+ */
+Config.prototype.getIgnoredWords = function (name_type) {
+  if (name_type == 'function-name') {
+    name_type = 'method-name';
+  }
+  var ignore = {
+    'class-name': [
+      'Middleware', 'Component', 'Controller', 'Repository', 'Interface', 'Transformer', 'Template'
+    ],
+    'method-name': [
+      'constructor', 'prototype', 'hasOwnProperty',
+      'isPrototypeOf', 'propertyIsEnumerable', 'toLocaleString',
+      'arguments',
+      'Middleware', 'Component', 'Controller', 'Repository', 'Interface', 'Transform', 'Template'
+    ],
+    'variable-name': [
+      'i', 'k', 'x', 'y', 'z', 'n', 'm', 'o', 'middleware', 'component', 'controller', 'repository', 'interface', 'transformer', 'template'
+    ],
+    'param-name': [
+      'middleware', 'component', 'controller', 'repository', 'interface', 'transformer', 'template'
+    ]
+  };
+
+  // 优先返回配置中的忽略词，其次返回硬编码忽略词
+  var config = this.config.ignored_words[name_type];
+  var hardcoded = ignore[name_type];
+
+  // 如果配置中的忽略词为空数组，则使用硬编码忽略词
+  if (config && config.length > 0) {
+    return config;
+  } else if (hardcoded && hardcoded.length > 0) {
+    return hardcoded;
+  }
+
+  return [];
+};
+
+module.exports = { Config };