mm_eslint 1.4.3 → 1.4.5

package/corrector.js

@@ -0,0 +1,375 @@
+const { Config } = require('./config');
+const { splitWords } = require('./util.js');
+/**
+ * 命名规范修正器类
+ * 负责修正命名问题
+ */
+class Corrector {
+  /**
+   * 构造函数
+   * @param {object} config 配置对象
+   */
+  constructor(config) {
+    this.config = config || new Config();
+  }
+}
+
+/**
+ * 获取修正建议
+ * @param {string} name 名称
+ * @param {object} error 错误信息
+ * @returns {string} 建议名称
+ */
+Corrector.prototype.getSuggestion = function (error) {
+  var word = '';
+  try {
+    var { words, rule } = error;
+    switch (error.type) {
+      case 'style':
+        word = this.fixStyle(words, rule);
+        break;
+      case 'length':
+        word = this.fixLength(words, rule);
+        break;
+      case 'word_length':
+        word = this.fixWordLength(words, rule);
+        break;
+      case 'forbidden_word':
+        word = this.fixForbiddenWord(words, rule);
+        break;
+      default:
+        return error.name;
+    }
+  } catch {
+    return error.name;
+  }
+  
+  var suggestion = error.prefix + word;
+  
+  // 检查建议名称是否与原名称相同，如果相同则不显示建议
+  if (suggestion === error.name || word === error.name) {
+    return null;
+  }
+  
+  return suggestion;
+};
+
+/**
+ * 缩写名称
+ * @param {string} name 名称
+ * @param {number} max_length 最大长度
+ * @returns {string} 缩写后的名称
+ */
+Corrector.prototype._abbreviateName = function (name, max_length) {
+  if (name.length <= max_length) {
+    return name;
+  }
+  // 先尝试推荐单词缩写，若失败则使用简单缩写策略
+  return this._abbreviateWord(name) || name.substring(0, max_length);
+};
+
+/**
+ * 推荐缩写单词
+ * @param {string} word 单词
+ * @returns {string} 缩写后的单词
+ */
+Corrector.prototype._abbreviateWord = function (word) {
+  // 智能缩写策略：优先使用常见缩写，其次使用截断
+  var common_abbreviations = {
+    'constants': 'const',
+    'configuration': 'config',
+    'application': 'app',
+    'information': 'info',
+    'temporary': 'temp',
+    'parameter': 'param',
+    'manager': 'mgr',
+    'processor': 'proc',
+    'controller': 'ctrl',
+    'handler': 'hdlr',
+    'service': 'svc',
+    'provider': 'prov',
+    'factory': 'fact',
+    'builder': 'bldr',
+    'adapter': 'adpt',
+    'decorator': 'deco',
+    'mediator': 'medi',
+    'observer': 'obs',
+    'strategy': 'strat',
+    'command': 'cmd',
+    'visitor': 'vis',
+    'iterator': 'iter',
+    'template': 'tmpl',
+    'interpreter': 'interp',
+    'component': 'comp',
+    'property': 'prop',
+    'entity': 'ent'
+  };
+
+  return common_abbreviations[word.toLowerCase()];
+};
+
+/**
+ * 转换命名风格
+ * @param {string} name 名称
+ * @param {string} target_style 目标风格
+ * @returns {string} 转换后的名称
+ */
+Corrector.prototype.convertStyle = function (name, target_style) {
+  var words = splitWords(name);
+  return this.fixName(words, target_style);
+};
+
+/**
+ * 修正名称风格
+ * @param {array} words 单词数组
+ * @param {string} style 命名风格
+ * @returns {string} 修正后的名称
+ */
+Corrector.prototype.fixName = function (words, style) {
+  let name = '';
+  switch (style) {
+    // 小写蛇形命名 （变量命名）
+    case 'snake_case':
+      for (let i = 0; i < words.length; i++) {
+        words[i] = words[i].toLowerCase();
+      }
+      name = words.join('_');
+      break;
+    // 小驼峰命名 （函数命名）
+    case 'camelCase':
+      for (let i = 0; i < words.length; i++) {
+        words[i] = words[i].toLowerCase();
+        if (i > 0) {
+          words[i] = words[i].charAt(0).toUpperCase() + words[i].substring(1);
+        }
+      }
+      name = words.join('');
+      break;
+    // 大驼峰命名 （类命名）
+    case 'PascalCase':
+      for (let i = 0; i < words.length; i++) {
+        words[i] = words[i].toLowerCase();
+        words[i] = words[i].charAt(0).toUpperCase() + words[i].substring(1);
+      }
+      name = words.join('');
+      break;
+    // 大写蛇形命名 （常量命名）
+    case 'UPPER_SNAKE_CASE':
+      for (let i = 0; i < words.length; i++) {
+        words[i] = words[i].toUpperCase();
+      }
+      name = words.join('_');
+      break;
+    // 小写命名 （变量命名）
+    case 'lowercase':
+      for (let i = 0; i < words.length; i++) {
+        words[i] = words[i].toLowerCase();
+      }
+      name = words.join('');
+      break;
+    // 大写命名 （常量命名）
+    case 'UPPERCASE':
+      for (let i = 0; i < words.length; i++) {
+        words[i] = words[i].toUpperCase();
+      }
+      name = words.join('');
+      break;
+    // 短横线命名 （拨号命名）
+    case 'kebab-case':
+      for (let i = 0; i < words.length; i++) {
+        words[i] = words[i].toLowerCase();
+      }
+      name = words.join('-');
+      break;
+    // 大写短横线命名 （密钥命名）
+    case 'UPPER-KEBAB-CASE':
+      for (let i = 0; i < words.length; i++) {
+        words[i] = words[i].toUpperCase();
+      }
+      name = words.join('-');
+      break;
+  }
+
+  return name;
+}
+
+/**
+ * 修正命名风格
+ * @param {string[]} words 单词数组
+ * @param {object} rule 规则配置
+ * @returns {string} 修正后的命名风格
+ */
+Corrector.prototype.fixStyle = function (words, rule) {
+  var new_words = this._getNewWords(words, rule);
+  return this.fixName(new_words, rule.styles[0]);
+}
+
+/**
+ * 修正名称长度
+ * @param {string[]} words 单词数组
+ * @param {object} rule 规则配置
+ * @returns {string} 修正后的名称长度
+ */
+Corrector.prototype.fixLength = function (words, rule) {
+  var new_words = this._getNewWords(words, rule);
+  new_words[0] = this._abbreviateName(new_words[0], rule.max);
+  return this.fixName(new_words, rule.styles[0]);
+}
+
+/**
+ * 修正单词长度
+ * @param {string[]} words 单词数组
+ * @param {object} rule 规则配置
+ * @returns {string} 修正后的单词长度
+ */
+Corrector.prototype.fixWordLength = function (words, rule) {
+  var new_words = this._getNewWords(words, rule);
+  for (let i = 0; i < new_words.length; i++) {
+    if (new_words[i].length > rule.single_word_len) {
+      new_words[i] = new_words[i].substring(0, 4);
+    }
+  }
+  return this.fixName(new_words, rule.styles[0]);
+}
+
+/**
+ * 获取新的单词数组
+ * @param {string[]} words 单词数组
+ * @param {object} rule 规则配置
+ * @returns {string[]} 新的单词数组
+ */
+Corrector.prototype._getNewWords = function (words, rule) {
+  var new_words = this._filterForbiddenWord(words, rule.forbidden_words);
+  return this._toRecommendWords(new_words, rule.recommend_words, rule.single_word_len);
+}
+
+/**
+ * 修正禁止词汇
+ * @param {string[]} words 单词数组
+ * @param {object} rule 规则配置
+ * @returns {string} 修正后的禁止词汇
+ */
+Corrector.prototype.fixForbiddenWord = function (words, rule) {
+  var new_words = this._filterForbiddenWord(words, rule.forbidden_words);
+  return this.fixName(new_words, rule.styles[0]);
+}
+
+/**
+ * 是否禁止拼接词
+ * @param {string} word 单词
+ * @param {object} rule 规则配置
+ * @returns {boolean} 是否禁止拼接词
+ */
+Corrector.prototype._isForbiddenWord = function (word, forbidden_words) {
+  for (let i = 0; i < forbidden_words.length; i++) {
+    let forbidden_word = forbidden_words[i];
+    if (word.toLowerCase() === forbidden_word.toLowerCase()) {
+      return true;
+    }
+  }
+  return false;
+}
+
+/**
+ * 过滤禁止拼接词
+ */
+Corrector.prototype._filterForbiddenWord = function (words, forbidden_words) {
+  var new_word = [];
+  for (let i = 0; i < words.length; i++) {
+    let word = words[i];
+    if (!this._isForbiddenWord(word, 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 单词数组
+ * @param {object} recommend 推荐配置
+ * @param {number} single_word_len 单个单词长度
+ * @returns {string[]} 推荐的单词数组
+ */
+Corrector.prototype._toRecommendWords = function (words, recommend, single_word_len) {
+  let recommend_words = [];
+  for (let i = 0; i < words.length; i++) {
+    let word = words[i];
+    if (word.length > single_word_len) {
+      var recommend_word = this._getRecommendWord(word, recommend);
+      if (recommend_word) {
+        word = recommend_word;
+      }
+    }
+    recommend_words.push(word);
+  }
+  return recommend_words;
+}
+
+/**
+ * 获取推荐的单词
+ * @param {string} word 单词
+ * @param {object} recommend 推荐配置
+ * @returns {string} 推荐的单词
+ */
+Corrector.prototype._getRecommendWord = function (word, recommend) {
+  var recommend_word = null;
+  for (var k in recommend) {
+    let arr = recommend[k];
+    for (let i = 0; i < arr.length; i++) {
+      let recommended = arr[i];
+      if (word.toLowerCase() === recommended.toLowerCase()) {
+        recommend_word = k;
+        continue;
+      }
+    }
+  }
+  return recommend_word;
+}
+
+module.exports = { Corrector };