mm_eslint 1.4.3 → 1.4.4

package/config.js

@@ -1,573 +1,588 @@
-/**
- * 命名规范检测配置类
- */
-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': [],
-        'param-name': []
-      },
-      // 推荐词
-      recommended_words: {
-        'class-name': {
-        },
-        'method-name': {
-        },
-        'variable-name': {
-        },
-        'constant-name': {
-        },
-        'param-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），私有属性类使用私有大驼峰命名法（_PascalCase），长度{min}-{max}字符，且优先使用单个单词，每个单词不超过{word_len}字符',
-      min: 1,
-      max: 20,
-      styles: ['PascalCase', '_PascalCase'],
-      single_word: true,
-      single_word_len: 8
-    },
-    'property-instance-class-name': {
-      name: '属性实例类名',
-      message:
-        '属性实例类必须使用小驼峰命名法（camelCase），私有属性实例类使用私有小驼峰命名法（_camelCase），长度{min}-{max}字符，且优先使用单个单词，每个单词不超过{word_len}字符',
-      min: 1,
-      max: 20,
-      styles: ['camelCase', '_camelCase'],
-      single_word: true,
-      single_word_len: 8
-    },
-    'property-method-name': {
-      name: '属性方法名',
-      message:
-        '属性方法必须使用小驼峰命名法（camelCase），私有属性方法使用私有小驼峰命名法（_camelCase），长度{min}-{max}字符，且优先使用单个单词，每个单词不超过{word_len}字符',
-      min: 1,
-      max: 20,
-      styles: ['camelCase', '_camelCase'],
-      single_word: true,
-      single_word_len: 8
-    },
-    'property-value-name': {
-      name: '属性值名',
-      message:
-        '属性值必须使用小写蛇形命名法（snake_case），私有属性值使用私有蛇形命名法（_snake_case），常量属性值使用大写蛇形命名法（UPPER_SNAKE_CASE），长度{min}-{max}字符，且优先使用单个单词，每个单词不超过{word_len}字符',
-      min: 1,
-      max: 20,
-      styles: ['snake_case', '_snake_case', 'UPPER_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) {
-  let type = name_type.replace('property-', '').replace('instance-', '');
-  if (type == 'function-name') {
-    type = 'method-name';
-  }
-  else if (type == 'value-name') {
-    type = 'variable-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',
-      'with'
-    ],
-    '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',
-      'manager',
-      'processor',
-      'controller',
-      'service',
-      'middleware',
-      'component',
-      'provider'
-    ],
-    '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'
-    ],
-    "param-name": [
-      'param',
-      'params',
-      'parameter',
-      'parameters'
-    ]
-  };
-
-  // 优先返回配置中的禁用词，其次返回硬编码禁用词
-  var config = this.config.forbidden_words[type];
-  var hardcoded = forbidden[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) {
-  let type = name_type.replace('property-', '').replace('instance-', '');
-  if (type == 'function-name') {
-    type = 'method-name';
-  }
-  else if (type == 'value-name') {
-    type = 'variable-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'],
-      'Obs': ['Observer'],
-      'Strat': ['Strategy'],
-      'Mnt': ['Memento'],
-      'Intp': ['Interpreter'],
-      'Cmp': ['Component'],
-      'Info': ['Information'],
-      'Conn': ['Connection'],
-      'Ext': ['Extension'],
-      'Asst': ['Assistant'],
-      'Const': ['Constants', 'Constant']
-    },
-    'method-name': {
-      'get': ['fetch', 'retrieve', 'obtain', 'query'],
-      'set': ['setting', 'update'],
-      'add': ['append', 'insert'],
-      'del': ['delete'],
-      'check': ['validate', 'verify'],
-      'calc': ['calculate', 'compute', 'evaluate'],
-      'init': ['initialize', 'initialization', 'prepare'],
-      'gen': ['generate'],
-      'exec': ['execute'],
-      'run': ['process', 'handle'],
-      'load': ['retrieve'],
-      'save': ['persist'],
-      'cmp': ['compare'],
-      'copy': ['duplicate'],
-      'move': ['transfer'],
-      'to': ['convert', 'transform', 'transformation'],
-      'create': ['construct'],
-      'avg': ['average'],
-      'zip': ['compress'],
-      'unzip': ['decompress'],
-      'env': ['Environment'],
-      'auth': ['authorize', 'Authentication'],
-      'authz': ['Authorization'],
-      'valid': ['Validation'],
-      'stringify': ['serialize', 'serialization'],
-      'parse': ['deserialize', 'deserialization'],
-      'impl': ['Implementation'],
-      // 名词
-      'App': ['Application'],
-      'Conn': ['Connection'],
-      'Info': ['Information'],
-      'Config': ['Configure', 'Configuration']
-    },
-    'variable-name': {
-      'obj': ['object'],
-      'arr': ['array'],
-      'str': ['string'],
-      'num': ['number'],
-      'bool': ['boolean'],
-      'fn': ['function'],
-      'tmp': ['temporary'],
-      'def': ['default'],
-      'max': ['maximum'],
-      'min': ['minimum'],
-      'avg': ['average'],
-      'app': ['application'],
-      'connect': ['connection'],
-      'info': ['information'],
-      'config': ['configure', 'configuration'],
-      'var': ['variable']
-    },
-    'constant-name': {
-      'MAX': ['MAXIMUM'],
-      'MIN': ['MINIMUM'],
-      'AVG': ['AVERAGE'],
-      'APP': ['APPLICATION'],
-      'INFO': ['INFORMATION'],
-      'CONFIG': ['CONFIGURE', 'CONFIGURATION'],
-      'VAL': ['VALUE'],
-      'NUM': ['NUMBER'],
-      'STR': ['STRING'],
-      'BOOL': ['BOOLEAN'],
-      'ARR': ['ARRAY'],
-      'OBJ': ['OBJECT'],
-      'FUNC': ['FUNCTION']
-    }
-  };
-
-  // 优先返回配置中的推荐词，其次返回硬编码推荐词
-  var config = this.config.recommended_words[type];
-  var hardcoded = recommend[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) {
-  let type = name_type.replace('property-', '').replace('instance-', '');
-  if (type == 'function-name') {
-    type = 'method-name';
-  }
-  var ignore = {
-    'class-name': [
-      'exports', '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', '$',
-      'timestamp', 'extensions'
-    ],
-    'param-name': [
-      'middleware', 'component', 'controller', 'repository', 'interface', 'transformer', 'template',
-      'timestamp', 'extensions'
-    ],
-    'value-name': [
-      '$', // 忽略$符号的属性值名
-      'middleware',
-      'component',
-      'controller',
-      'service',
-      'repository',
-      'interface',
-      'transformer',
-      'template',
-      'timestamp', 'extensions'
-    ]
-  };
-
-  // 优先返回配置中的忽略词，其次返回硬编码忽略词
-  var config = this.config.ignored_words[type];
-  var hardcoded = ignore[type];
-
-  // 如果配置中的忽略词为空数组，则使用硬编码忽略词
-  if (config && config.length > 0) {
-    return config;
-  } else if (hardcoded && hardcoded.length > 0) {
-    return hardcoded;
-  }
-
-  return [];
-};
-
-module.exports = { Config };
+/**
+ * 命名规范检测配置类
+ * 负责提供配置，风格、长度等
+ */
+class Config {
+  /**
+   * 构造函数
+   * @param {object} config 配置对象
+   */
+  constructor(config) {
+    this.config = Object.assign({
+      // 忽略词
+      ignore_words: {
+        'class': [],
+        'class-instance': [],
+        'function': [],
+        'param': [],
+        'variable': [],
+        'constant': []
+      },
+      // 禁止拼接词
+      forbidden_words: {
+        'class': [],
+        'class-instance': [],
+        'function': [],
+        'param': [],
+        'variable': [],
+        'constant': []
+      },
+      // 推荐词
+      recommended_words: {
+        'class': {},
+        'class-instance': {},
+        'function': {},
+        'param': {},
+        'variable': {},
+        'constant': {}
+      }
+    }, 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]+)*$/,
+    "kebab-case": /^[a-z]+([a-z0-9-])*$/,
+    "UPPER-KEBAB-CASE": /^[A-Z]+([A-Z0-9-])*$/
+  };
+  return regex[style] || null;
+};
+
+/**
+ * 获取命名类型的禁止拼接词列表
+ * @param {string} name_type 命名类型
+ * @returns {Array} 禁止拼接词列表
+ */
+Config.prototype.getForbiddenWords = function (name_type) {
+  let type = name_type.replace('property-', '').replace('instance-', '');
+  var forbidden = {
+    'class': [
+      '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',
+    ],
+    'function': [
+      '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',
+      'with'
+    ],
+    'variable': [
+      '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',
+      'manager',
+      'processor',
+      'controller',
+      'service',
+      'middleware',
+      'component',
+      'provider'
+    ],
+    'constant': [
+      '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'
+    ],
+    "param": [
+      'param',
+      'params',
+      'parameter',
+      'parameters'
+    ]
+  };
+
+  // 优先返回配置中的禁用词，其次返回硬编码禁用词
+  var config = this.config.forbidden_words[type];
+  var hardcoded = forbidden[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.getBaseRule = function (name_type) {
+  var rule = {
+    'class': {
+      name: '类名',
+      min: 1,
+      max: 20,
+      styles: ['PascalCase'],
+      single_word: true,
+      single_word_len: 8  // 类名允许更长的单词，因为需要表达复杂语义
+    },
+    'class-instance': {
+      name: '类实例名',
+      min: 1,
+      max: 20,
+      styles: ['camelCase'],
+      single_word: true,
+      single_word_len: 8
+    },
+    'function': {
+      name: '函数名',
+      min: 1,
+      max: 20,
+      styles: ['camelCase'],
+      single_word: true,
+      single_word_len: 8
+    },
+    'param': {
+      name: '参数名',
+      min: 1,
+      max: 20,
+      styles: ['snake_case', 'camelCase', 'PascalCase'],
+      single_word: true,
+      single_word_len: 8
+    },
+    'variable': {
+      name: '变量名',
+      min: 1,
+      max: 20,
+      styles: ['snake_case'],
+      single_word: true,
+      single_word_len: 8
+    },
+    'constant': {
+      name: '常量名',
+      min: 1,
+      max: 20,
+      styles: ['UPPER_SNAKE_CASE'],
+      single_word: true,
+      single_word_len: 8
+    }
+  };
+  return rule[name_type] || null;
+}
+
+/**
+ * 获取命名类型的规则配置
+ * @param {string} name_type 命名类型
+ * @returns {object} 规则配置对象
+ */
+Config.prototype.getRule = function (name_type) {
+  var rule = this.getBaseRule(name_type);
+  if (rule) {
+    rule.ignore_words = this.getIgnoreWords(name_type);
+    rule.forbidden_words = this.getForbiddenWords(name_type);
+    rule.recommend_words = this.getRecommendWords(name_type);
+  }
+  return rule;
+};
+
+/**
+ * 获取推荐词映射
+ * @param {string} 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';
+  }
+  var recommend = {
+    'class': {
+      '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'],
+      'Obs': ['Observer'],
+      'Strat': ['Strategy'],
+      'Mnt': ['Memento'],
+      'Intp': ['Interpreter'],
+      'Cmp': ['Component'],
+      'Info': ['Information'],
+      'Conn': ['Connection'],
+      'Ext': ['Extension'],
+      'Asst': ['Assistant'],
+      'Const': ['Constants', 'Constant'],
+      'Info': ['Information'],
+      'Store': ['Repository']
+    },
+    'function': {
+      'get': ['fetch', 'retrieve', 'obtain', 'query'],
+      'set': ['setting', 'update'],
+      'add': ['append', 'insert'],
+      'del': ['delete'],
+      'check': ['validate', 'verify'],
+      'calc': ['calculate', 'compute', 'evaluate'],
+      'init': ['initialize', 'initialization', 'prepare'],
+      'gen': ['generate'],
+      'exec': ['execute'],
+      'run': ['process', 'handle'],
+      'load': ['retrieve'],
+      'save': ['persist'],
+      'cmp': ['compare'],
+      'copy': ['duplicate'],
+      'move': ['transfer'],
+      'to': ['convert', 'transform', 'transformation'],
+      'create': ['construct'],
+      'avg': ['average'],
+      'zip': ['compress'],
+      'unzip': ['decompress'],
+      'env': ['Environment'],
+      'auth': ['authorize', 'Authentication'],
+      'authz': ['Authorization'],
+      'valid': ['Validation'],
+      'stringify': ['serialize', 'serialization'],
+      'parse': ['deserialize', 'deserialization'],
+      'impl': ['Implementation'],
+      // 名词
+      'App': ['Application'],
+      'Conn': ['Connection'],
+      'Info': ['Information'],
+      'Config': ['Configure', 'Configuration']
+    },
+    'variable': {
+      'obj': ['object'],
+      'arr': ['array'],
+      'str': ['string'],
+      'num': ['number'],
+      'bool': ['boolean'],
+      'fn': ['function'],
+      'tmp': ['temporary'],
+      'def': ['default'],
+      'max': ['maximum'],
+      'min': ['minimum'],
+      'avg': ['average'],
+      'app': ['application'],
+      'connect': ['connection'],
+      'info': ['information'],
+      'config': ['configure', 'configuration'],
+      'var': ['variable']
+    },
+    'constant': {
+      'MAX': ['MAXIMUM'],
+      'MIN': ['MINIMUM'],
+      'AVG': ['AVERAGE'],
+      'APP': ['APPLICATION'],
+      'INFO': ['INFORMATION'],
+      'CONFIG': ['CONFIGURE', 'CONFIGURATION'],
+      'VAL': ['VALUE'],
+      'NUM': ['NUMBER'],
+      'STR': ['STRING'],
+      'BOOL': ['BOOLEAN'],
+      'ARR': ['ARRAY'],
+      'OBJ': ['OBJECT'],
+      'FUNC': ['FUNCTION']
+    }
+  };
+
+  // 优先返回配置中的推荐词，其次返回硬编码推荐词
+  var config = this.config.recommended_words[type];
+  var hardcoded = recommend[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.getIgnoreWords = function (name_type) {
+  let type = name_type.replace('property-', '').replace('instance-', '');
+  var ignore = {
+    'class': [
+      'exports', 'Middleware', 'Component', 'Controller', 'Repository', 'Interface', 'Transformer', 'Template'
+    ],
+    'function': [
+      'constructor', 'prototype', 'hasOwnProperty',
+      'isPrototypeOf', 'propertyIsEnumerable', 'toLocaleString',
+      'arguments',
+      'Middleware', 'Component', 'Controller', 'Repository', 'Interface', 'Transform', 'Template'
+    ],
+    'variable': [
+      'i', 'k', 'x', 'y', 'z', 'n', 'm', 'o', 'middleware', 'component', 'controller', 'repository', 'interface', 'transformer', 'template', '$',
+      'timestamp', 'extensions'
+    ],
+    'param': [
+      'middleware', 'component', 'controller', 'repository', 'interface', 'transformer', 'template',
+      'timestamp', 'extensions'
+    ],
+    'value': [
+      '$', // 忽略$符号的属性值名
+      'middleware',
+      'component',
+      'controller',
+      'service',
+      'repository',
+      'interface',
+      'transformer',
+      'template',
+      'timestamp', 'extensions'
+    ]
+  };
+
+  // 优先返回配置中的忽略词，其次返回硬编码忽略词
+  var config = this.config.ignore_words[type];
+  var hardcoded = ignore[type];
+
+  // 如果配置中的忽略词为空数组，则使用硬编码忽略词
+  if (config && config.length > 0) {
+    return config;
+  } else if (hardcoded && hardcoded.length > 0) {
+    return hardcoded;
+  }
+
+  return [];
+};
+
+/**
+ * 获取命名类型的中文描述
+ * @param {string} name_type 命名类型
+ * @returns {string} 中文描述
+ */
+Config.prototype.getTypeName = function (name_type) {
+  var type_name_map = this.getTypeNameMap();
+  return type_name_map[name_type] || '名称';
+}
+
+/**
+ * 获取命名类型的中文描述
+ * @returns {object} 命名类型映射表
+ */
+Config.prototype.getTypeNameMap = function () {
+    var type_name_map = {
+    'function': '函数',
+    'variable': '变量',
+    'param': '参数',
+    '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': '私有变量'
+  };
+  return type_name_map;
+}
+
+/**
+ * 获取风格名称的中文描述
+ * @param {string} style 风格
+ * @returns {string} 中文描述
+ */
+Config.prototype.getStyleName = function (style) {
+  var style_name_map = this.getStyleNameMap();
+  return style_name_map[style] || style;
+}
+
+/**
+ * 获取风格名称的中文描述
+ * @returns {object} 风格名称映射表
+ */
+Config.prototype.getStyleNameMap = function () {
+    var style_name_map = {
+    'snake_case': '小写蛇形命名法',
+    'camelCase': '小驼峰命名法',
+    'PascalCase': '大驼峰命名法',
+    'UPPER_CASE': '大写蛇形命名法',
+    'lowercase': '小写命名法',
+    'UPPERCASE': '大写命名法',
+    'lowercase': '小写命名法',
+    'kebab-case': '短横线命名法',
+    'UPPERCASE_KEBAB_CASE': '大写短横线命名法'
+  };
+  return style_name_map;
+}
+
+module.exports = { Config };