mm_eslint 1.4.1 → 1.4.2

package/config.js

@@ -13,15 +13,15 @@ class Config {
         'class-name': [],
         'method-name': [],
         'variable-name': [],
-        'constant-name': [],
-        'property-value-name': [] // 忽略$符号的属性值名
+        'constant-name': []
       },
-      // 禁止词
+      // 禁止拼接词
       forbidden_words: {
         'class-name': [],
         'method-name': [],
         'variable-name': [],
-        'constant-name': []
+        'constant-name': [],
+        'param-name': []
       },
       // 推荐词
       recommended_words: {
@@ -32,6 +32,8 @@ class Config {
         'variable-name': {
         },
         'constant-name': {
+        },
+        'param-name': {
         }
       }
     }, config);
@@ -79,7 +81,7 @@ Config.prototype.getRule = function (name_type) {
     'function-name': {
       name: '函数名',
       message:
-        '必须使用小驼峰命名法（camelCase），长度{min}-{max}字符，且优先使用单个单词，每个单词不超过{word_len}字符',
+        '必须使用小驼峰命名法（camelCase），长度{min}-{max}字符，且优先使用单个单词，每个单词不超过{word_len}字符，不允许使用私有函数',
       min: 1,
       max: 20,
       styles: ['camelCase'],
@@ -129,40 +131,40 @@ Config.prototype.getRule = function (name_type) {
     'property-class-name': {
       name: '属性类名',
       message:
-        '属性类必须使用大驼峰命名法（PascalCase），长度{min}-{max}字符，且优先使用单个单词，每个单词不超过{word_len}字符',
+        '属性类必须使用大驼峰命名法（PascalCase），私有属性类使用私有大驼峰命名法（_PascalCase），长度{min}-{max}字符，且优先使用单个单词，每个单词不超过{word_len}字符',
       min: 1,
       max: 20,
-      styles: ['PascalCase'],
+      styles: ['PascalCase', '_PascalCase'],
       single_word: true,
       single_word_len: 8
     },
     'property-instance-class-name': {
       name: '属性实例类名',
       message:
-        '属性实例类必须使用小驼峰命名法（camelCase），长度{min}-{max}字符，且优先使用单个单词，每个单词不超过{word_len}字符',
+        '属性实例类必须使用小驼峰命名法（camelCase），私有属性实例类使用私有小驼峰命名法（_camelCase），长度{min}-{max}字符，且优先使用单个单词，每个单词不超过{word_len}字符',
       min: 1,
       max: 20,
-      styles: ['camelCase'],
+      styles: ['camelCase', '_camelCase'],
       single_word: true,
       single_word_len: 8
     },
     'property-method-name': {
       name: '属性方法名',
       message:
-        '属性方法必须使用小驼峰命名法（camelCase），长度{min}-{max}字符，且优先使用单个单词，每个单词不超过{word_len}字符',
+        '属性方法必须使用小驼峰命名法（camelCase），私有属性方法使用私有小驼峰命名法（_camelCase），长度{min}-{max}字符，且优先使用单个单词，每个单词不超过{word_len}字符',
       min: 1,
       max: 20,
-      styles: ['camelCase'],
+      styles: ['camelCase', '_camelCase'],
       single_word: true,
       single_word_len: 8
     },
     'property-value-name': {
       name: '属性值名',
       message:
-        '属性值必须使用小写蛇形命名法（snake_case），长度{min}-{max}字符，且优先使用单个单词，每个单词不超过{word_len}字符',
+        '属性值必须使用小写蛇形命名法（snake_case），私有属性值使用私有蛇形命名法（_snake_case），常量属性值使用大写蛇形命名法（UPPER_SNAKE_CASE），长度{min}-{max}字符，且优先使用单个单词，每个单词不超过{word_len}字符',
       min: 1,
       max: 20,
-      styles: ['snake_case'],
+      styles: ['snake_case', '_snake_case', 'UPPER_SNAKE_CASE'],
       single_word: true,
       single_word_len: 8
     },
@@ -182,14 +184,17 @@ Config.prototype.getRule = function (name_type) {
 };
 
 /**
- * 获取命名类型的禁止词列表
+ * 获取命名类型的禁止拼接词列表
  * @param {string} name_type 命名类型
- * @returns {Array} 禁止词列表
+ * @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';
+  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': [
@@ -267,6 +272,7 @@ Config.prototype.getForbiddenWords = function (name_type) {
       'buffered',
       'idx',
       'counter',
+      'with'
     ],
     'variable-name': [
       'object',
@@ -307,7 +313,12 @@ Config.prototype.getForbiddenWords = function (name_type) {
       'entity',
       'column',
       'property',
-      'attribute'
+      'attribute',
+      'manager',
+      'processor',
+      'controller',
+      'service',
+      'provider'
     ],
     'constant-name': [
       'manager',
@@ -355,12 +366,18 @@ Config.prototype.getForbiddenWords = function (name_type) {
       'cached',
       'buffer',
       'buffered'
+    ],
+    "param-name": [
+      'param',
+      'params',
+      'parameter',
+      'parameters'
     ]
   };
 
   // 优先返回配置中的禁用词，其次返回硬编码禁用词
-  var config = this.config.forbidden_words[name_type];
-  var hardcoded = forbidden[name_type];
+  var config = this.config.forbidden_words[type];
+  var hardcoded = forbidden[type];
 
   // 如果配置中的禁用词为空数组，则使用硬编码禁用词
   if (config && config.length > 0) {
@@ -378,9 +395,12 @@ Config.prototype.getForbiddenWords = function (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';
+  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': {
@@ -407,17 +427,17 @@ Config.prototype.getRecommendedWords = function (name_type) {
       'Info': ['Information'],
       'Conn': ['Connection'],
       'Ext': ['Extension'],
-      'Asst': ['Assistant']
+      'Asst': ['Assistant'],
+      'Const': ['Constants', 'Constant']
     },
     'method-name': {
       'get': ['fetch', 'retrieve', 'obtain', 'query'],
-      'set': ['assign', 'setting', 'update'],
+      'set': ['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'],
@@ -427,14 +447,10 @@ Config.prototype.getRecommendedWords = function (name_type) {
       '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'],
@@ -442,8 +458,11 @@ Config.prototype.getRecommendedWords = function (name_type) {
       'stringify': ['serialize', 'serialization'],
       'parse': ['deserialize', 'deserialization'],
       'impl': ['Implementation'],
-      'info': ['Information'],
-      'conn': ['Connection']
+      // 名词
+      'App': ['Application'],
+      'Conn': ['Connection'],
+      'Info': ['Information'],
+      'Config': ['Configure', 'Configuration']
     },
     'variable-name': {
       'obj': ['object'],
@@ -456,18 +475,33 @@ Config.prototype.getRecommendedWords = function (name_type) {
       'def': ['default'],
       'max': ['maximum'],
       'min': ['minimum'],
-      'avg': ['average']
+      'avg': ['average'],
+      'app': ['application'],
+      'connect': ['connection'],
+      'info': ['information'],
+      'config': ['configure', 'configuration'],
+      'var': ['variable']
     },
     'constant-name': {
-      'MAX': ['Maximum'],
-      'MIN': ['Minimum'],
-      'AVG': ['Average']
+      '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[name_type];
-  var hardcoded = recommend[name_type];
+  var config = this.config.recommended_words[type];
+  var hardcoded = recommend[type];
 
   // 如果配置中的推荐词不为空对象，则使用配置推荐词
   if (config && Object.keys(config).length > 0) {
@@ -485,9 +519,9 @@ Config.prototype.getRecommendedWords = function (name_type) {
  * @returns {Array} 忽略词列表
  */
 Config.prototype.getIgnoredWords = function (name_type) {
-  name_type = name_type.replace('property-', '').replace('instance-', '');
-  if (name_type == 'function-name') {
-    name_type = 'method-name';
+  let type = name_type.replace('property-', '').replace('instance-', '');
+  if (type == 'function-name') {
+    type = 'method-name';
   }
   var ignore = {
     'class-name': [
@@ -521,8 +555,8 @@ Config.prototype.getIgnoredWords = function (name_type) {
   };
 
   // 优先返回配置中的忽略词，其次返回硬编码忽略词
-  var config = this.config.ignored_words[name_type];
-  var hardcoded = ignore[name_type];
+  var config = this.config.ignored_words[type];
+  var hardcoded = ignore[type];
 
   // 如果配置中的忽略词为空数组，则使用硬编码忽略词
   if (config && config.length > 0) {