@lwys-pkg-releaser/node-bullshit-generator/lib/狗屁库.js

Port of menzi11/BullshitGenerator@github.com to JavaScript

"use strict";

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }

function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }

function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }

/**
 * node-bullshit-generator
 * @author Dobby233Liu
 * @license Anti-996 License 1.0
 */
var 常用 = require("./常用");

var 随机 = require("./随机常用");

var _require = require("./符号常量"),
    逗号 = _require.逗号,
    非结段符号 = _require.非结段符号,
    使不能以句号结段的结段符号 = _require.使不能以句号结段的结段符号,
    标点符号 = _require.标点符号;

var 默认选项 = {
  /**
   * 如果为真，生成的每一句名人名言会有1/10的概率缺少后面垫话
   */
  有概率不添加后面垫话: false,

  /**
   * 如果为真，启用本库在原版狗屁不通文章生成器的基础上增加的主要针对语法的改进
   */
  v3语法改进: true,

  /**
   * 如果为真，启用原版 PR #175 中“显著降低垫话重复度”的功能
   */
  "menzi11#175": true,

  /**
   * 如果为真，生成过程中会调用字典中的callback函数
   */
  允许字典处理字符串: true,

  /**
   * 如果为真，生成函数会返回在生成过程中程序产生的“文章”数组
   */
  返回段落列表: false,

  /**
   * 如果为真，生成函数在计算文章字数时会将换行符和仍在生成的段落的字数也计算在内
   */
  能写少就写少: true,

  /**
   * 如果为真，生成函数会确保生成的文章的结尾带标点符号
   */
  文章结尾强制带标点符号: false
};

var 默认字典 = require("./dict/default/配置");
/**
 * 库的主类
 * @author Dobby233Liu
 */


var 狗屁库 = /*#__PURE__*/function () {
  function 狗屁库() {
    _classCallCheck(this, 狗屁库);

    _defineProperty(this, "generate", this.生成);
  }

  _createClass(狗屁库, [{
    key: "\u751F\u6210",
    value:
    /**
     * 生成一篇废话文章
     * @param {string} 主题
     * @param {number} 长度
     * @param {Object} 字典 - 应包含的属性见{@link dict/default/配置.js}
     * @param {Object} 选项 - 可用选项见 {@link 默认选项}
     * @returns {string|array} 如果选项中的 `返回段落列表` 属性为真，返回 array，否则返回 string
     */
    function 生成() {
      var 主题 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : "学生会退会";
      var 长度 = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 6000 * 主题.length;
      var 字典 = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 默认字典;
      var 选项 = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 默认选项;
      if (选项.文章结尾强制带标点符号 === undefined && 选项.结段强制带标点符号 !== undefined) // 确保兼容性
        选项.文章结尾强制带标点符号 = 选项.结段强制带标点符号;
      选项 = 常用.合并对象(选项, 默认选项);
      字典 = 常用.合并对象(字典, 默认字典);
      if (选项.允许字典处理字符串 && 字典.主题处理) 主题 = 字典.主题处理(主题, 字典, 选项, 常用, 随机);
      var 起段 = 字典.起段.replace(/\{主题\}/g, 主题);
      var 前面垫话 = 字典.前面垫话;
      var 后面垫话 = 字典.后面垫话;
      var 名人名言 = 字典.名人名言;
      var 废话 = 字典.废话;
      var 洗牌遍历重复度 = 选项.v3语法改进 ? 1 : 2;
      var 下一句前面垫话 = 选项["menzi11#175"] ? 随机.洗牌遍历(前面垫话, 洗牌遍历重复度) : [];
      var 下一句后面垫话 = 选项["menzi11#175"] ? 随机.洗牌遍历(后面垫话, 洗牌遍历重复度) : [];
      var 下一句名人名言 = 随机.洗牌遍历(名人名言, 洗牌遍历重复度);
      var 下一句废话 = 随机.洗牌遍历(废话, 洗牌遍历重复度);
      var 文章 = [];
      var 段缓冲 = "";

      var 最后一段 = function 最后一段() {
        var 段 = 段缓冲.length <= 0 ? 常用.最后一项(文章) : 段缓冲;
        return 段 ? 段.trim() : "";
      };

      while (常用.总长(文章, 选项.能写少就写少) + (选项.能写少就写少 ? 段缓冲.length : 0) < 长度 || 选项.v3语法改进 && 常用.是否以字符串结束(最后一段(), 非结段符号) || 选项.文章结尾强制带标点符号 && !常用.是否以字符串结束(最后一段(), 标点符号)) {
        var 缓冲 = "";
        var 类型 = "忽略";
        var 分支 = 随机.取随机数(100);

        if (分支 < 5 && (!选项.v3语法改进 || !(段缓冲.length <= 0 || 常用.是否以字符串结束(段缓冲.trim(), 逗号)))) {
          类型 = "新行";
        } else if (分支 < 20) {
          类型 = "名人名言";
        } else {
          类型 = "废话";
        }

        if (类型 == "新行" && (!选项.v3语法改进 || !常用.是否以字符串结束(段缓冲.trim(), 使不能以句号结段的结段符号))) {
          缓冲 = 字典.句号.replace(/\{主题\}/g, 主题);
        } else if (类型 == "名人名言") {
          缓冲 = 下一句名人名言.next().value.replace(/\{前面垫话\}/g, function () {
            return (选项["menzi11#175"] ? 下一句前面垫话.next().value : 随机.瞎选一个(前面垫话)).replace(/\{主题\}/g, 主题);
          }).replace(/\{后面垫话\}/g, !选项.有概率不添加后面垫话 || 随机.取随机数(10) != 1 ? function () {
            return (选项["menzi11#175"] ? 下一句后面垫话.next().value : 随机.瞎选一个(后面垫话)).replace(/\{主题\}/g, 主题);
          } : "");
        } else if (类型 == "废话") {
          缓冲 = 下一句废话.next().value.replace(/\{主题\}/g, 主题);
        }

        if (选项.允许字典处理字符串 && 字典.缓冲处理) 缓冲 = 字典.缓冲处理(缓冲, 字典, 选项, 常用, 随机, 类型);
        段缓冲 += 缓冲;

        if (类型 == "新行") {
          文章 = 常用.加段(文章, 起段 + 段缓冲);
          段缓冲 = "";
        } else if (常用.能加段(段缓冲)) {
          // 段落已包含换行符，但还未换行
          // 确保不吃掉在生成的段落
          var 最后一个换行符 = 段缓冲.lastIndexOf("\n");
          var 实际可加的文字 = 段缓冲.substring(0, 最后一个换行符);
          var 不加的文字 = 最后一个换行符 + 1 < 段缓冲.length ? 段缓冲.substring(最后一个换行符 + 1, 段缓冲.length) : "";
          文章 = 常用.加段(文章, 起段 + 实际可加的文字);
          段缓冲 = 不加的文字;
        }
      } // 循环结束后是否未加段


      if (段缓冲 != "") 文章 = 常用.加段(文章, 起段 + 段缓冲);
      段缓冲 = "";
      if (选项.允许字典处理字符串 && 字典.文章处理) 文章 = 字典.文章处理(文章, 字典, 选项, 常用, 随机);
      if (!选项.返回段落列表) 文章 = 文章.join("\n");
      return 文章;
    }
  }]);

  return 狗屁库;
}();

module.exports = 狗屁库;