babel-plugin-jsdoc-to-assert/lib/generators.js

Babel plugin convert jsdoc to assertion.

// LICENSE : MIT
"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.ThrowGenerator = exports.SpecGenerator = exports.NodeAssertGenerator = exports.SimpleGenerator = void 0;

var _util = require("./util");

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); return Constructor; }

var doctrine = require("doctrine");

var SimpleGenerator =
/*#__PURE__*/
function () {
  function SimpleGenerator() {
    _classCallCheck(this, SimpleGenerator);
  }

  _createClass(SimpleGenerator, [{
    key: "assert",
    value: function assert(expression) {
      var trimmedExpression = (0, _util.trimSpaceEachLine)(expression.split("\n")).join("");
      return "console.assert(".concat(trimmedExpression, ");");
    }
  }]);

  return SimpleGenerator;
}();

exports.SimpleGenerator = SimpleGenerator;

var NodeAssertGenerator =
/*#__PURE__*/
function () {
  function NodeAssertGenerator() {
    _classCallCheck(this, NodeAssertGenerator);
  }

  _createClass(NodeAssertGenerator, [{
    key: "assert",
    value: function assert(expression) {
      var trimmedExpression = (0, _util.trimSpaceEachLine)(expression.split("\n")).join("");
      return "assert(".concat(trimmedExpression, ", 'Invalid JSDoc: ").concat(trimmedExpression, "');");
    }
  }]);

  return NodeAssertGenerator;
}();

exports.NodeAssertGenerator = NodeAssertGenerator;

var SpecGenerator =
/*#__PURE__*/
function () {
  function SpecGenerator(tag) {
    _classCallCheck(this, SpecGenerator);

    this.nameOfValue = tag.name;
    this.typeString = doctrine.type.stringify(tag.type, {
      compact: true
    });
    this.jsdocLikeString = "@".concat(tag.title, " {").concat(this.typeString, "} ").concat(tag.name);
  }

  _createClass(SpecGenerator, [{
    key: "assert",
    value: function assert(expression) {
      var trimmedExpression = (0, _util.trimSpaceEachLine)(expression.split("\n")).join("");
      var expectedMessage = "Expected type: ".concat(this.jsdocLikeString);
      var actualMessage = "Actual value:";
      var failureMessage = "Failure assertion:";
      var actualValue = this.nameOfValue;
      return "console.assert(".concat(trimmedExpression, ", '").concat(expectedMessage, "\\n").concat(actualMessage, "', ").concat(actualValue, ",'\\n").concat(failureMessage, " ").concat(trimmedExpression, "');");
    }
  }]);

  return SpecGenerator;
}();

exports.SpecGenerator = SpecGenerator;

var ThrowGenerator =
/*#__PURE__*/
function () {
  function ThrowGenerator() {
    _classCallCheck(this, ThrowGenerator);
  }

  _createClass(ThrowGenerator, [{
    key: "assert",
    value: function assert(expression) {
      var trimmedExpression = (0, _util.trimSpaceEachLine)(expression.split("\n")).join("");
      return "if(!(".concat(trimmedExpression, ")){ throw new TypeError('Invalid JSDoc: ").concat(trimmedExpression, "'); }");
    }
  }]);

  return ThrowGenerator;
}();

exports.ThrowGenerator = ThrowGenerator;
//# sourceMappingURL=generators.js.map