tap
Version:
A Test-Anything-Protocol library for JavaScript
396 lines (327 loc) • 12.6 kB
JavaScript
"use strict";
var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.default = void 0;
var _typeof2 = _interopRequireDefault(require("@babel/runtime/helpers/typeof"));
var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
var _warnings = require("../warnings");
var _constants = require("../constants");
var _errors = require("../errors");
var _stringify = require("../stringify");
var _tags = require("../tags");
var _string = require("../tags/failsafe/string");
var _Alias = _interopRequireDefault(require("./Alias"));
var _Collection = _interopRequireDefault(require("./Collection"));
var _Node = _interopRequireDefault(require("./Node"));
var _Pair = _interopRequireDefault(require("./Pair"));
var _Scalar = _interopRequireDefault(require("./Scalar"));
var isMap = function isMap(_ref) {
var type = _ref.type;
return type === _constants.Type.FLOW_MAP || type === _constants.Type.MAP;
};
var isSeq = function isSeq(_ref2) {
var type = _ref2.type;
return type === _constants.Type.FLOW_SEQ || type === _constants.Type.SEQ;
};
var Schema =
/*#__PURE__*/
function () {
function Schema(_ref3) {
var customTags = _ref3.customTags,
merge = _ref3.merge,
schema = _ref3.schema,
deprecatedCustomTags = _ref3.tags;
(0, _classCallCheck2.default)(this, Schema);
this.merge = !!merge;
this.name = schema;
this.tags = _tags.schemas[schema.replace(/\W/g, '')]; // 'yaml-1.1' -> 'yaml11'
if (!this.tags) {
var keys = Object.keys(_tags.schemas).map(function (key) {
return JSON.stringify(key);
}).join(', ');
throw new Error("Unknown schema \"".concat(schema, "\"; use one of ").concat(keys));
}
if (!customTags && deprecatedCustomTags) {
customTags = deprecatedCustomTags;
(0, _warnings.warnOptionDeprecation)('tags', 'customTags');
}
if (Array.isArray(customTags)) {
var _iteratorNormalCompletion = true;
var _didIteratorError = false;
var _iteratorError = undefined;
try {
for (var _iterator = customTags[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
var tag = _step.value;
this.tags = this.tags.concat(tag);
}
} catch (err) {
_didIteratorError = true;
_iteratorError = err;
} finally {
try {
if (!_iteratorNormalCompletion && _iterator.return != null) {
_iterator.return();
}
} finally {
if (_didIteratorError) {
throw _iteratorError;
}
}
}
} else if (typeof customTags === 'function') {
this.tags = customTags(this.tags.slice());
}
for (var i = 0; i < this.tags.length; ++i) {
var _tag = this.tags[i];
if (typeof _tag === 'string') {
var tagObj = _tags.tags[_tag];
if (!tagObj) {
var _keys = Object.keys(_tags.tags).map(function (key) {
return JSON.stringify(key);
}).join(', ');
throw new Error("Unknown custom tag \"".concat(_tag, "\"; use one of ").concat(_keys));
}
this.tags[i] = tagObj;
}
}
}
(0, _createClass2.default)(Schema, [{
key: "createNode",
value: function createNode(value, wrapScalars, tag, ctx) {
var tagObj;
if (tag) {
if (tag.startsWith('!!')) tag = Schema.defaultPrefix + tag.slice(2);
var match = this.tags.filter(function (t) {
return t.tag === tag;
});
tagObj = match.find(function (t) {
return !t.format;
}) || match[0];
if (!tagObj) throw new Error("Tag ".concat(tag, " not found"));
} else {
// TODO: deprecate/remove class check
tagObj = this.tags.find(function (t) {
return (t.identify && t.identify(value) || t.class && value instanceof t.class) && !t.format;
});
if (!tagObj) {
if (typeof value.toJSON === 'function') value = value.toJSON();
if ((0, _typeof2.default)(value) !== 'object') return wrapScalars ? new _Scalar.default(value) : value;
tagObj = value instanceof Map ? _tags.tags.map : value[Symbol.iterator] ? _tags.tags.seq : _tags.tags.map;
}
}
if (!ctx) ctx = {
wrapScalars: wrapScalars
};else ctx.wrapScalars = wrapScalars;
if (ctx.onTagObj) {
ctx.onTagObj(tagObj);
delete ctx.onTagObj;
}
var obj = {};
if (value && (0, _typeof2.default)(value) === 'object' && ctx.prevObjects) {
var prev = ctx.prevObjects.find(function (o) {
return o.value === value;
});
if (prev) {
var alias = new _Alias.default(prev); // leaves source dirty; must be cleaned by caller
ctx.aliasNodes.push(alias);
return alias;
}
obj.value = value;
ctx.prevObjects.push(obj);
}
obj.node = tagObj.createNode ? tagObj.createNode(this, value, ctx) : wrapScalars ? new _Scalar.default(value) : value;
return obj.node;
}
}, {
key: "createPair",
value: function createPair(key, value, ctx) {
var k = this.createNode(key, ctx.wrapScalars, null, ctx);
var v = this.createNode(value, ctx.wrapScalars, null, ctx);
return new _Pair.default(k, v);
} // falls back to string on no match
}, {
key: "resolveScalar",
value: function resolveScalar(str, tags) {
if (!tags) tags = this.tags;
for (var i = 0; i < tags.length; ++i) {
var _tags$i = tags[i],
format = _tags$i.format,
test = _tags$i.test,
resolve = _tags$i.resolve;
if (test) {
var match = str.match(test);
if (match) {
var res = resolve.apply(null, match);
if (!(res instanceof _Scalar.default)) res = new _Scalar.default(res);
if (format) res.format = format;
return res;
}
}
}
if (this.tags.scalarFallback) str = this.tags.scalarFallback(str);
return new _Scalar.default(str);
} // sets node.resolved on success
}, {
key: "resolveNode",
value: function resolveNode(doc, node, tagName) {
var tags = this.tags.filter(function (_ref4) {
var tag = _ref4.tag;
return tag === tagName;
});
var generic = tags.find(function (_ref5) {
var test = _ref5.test;
return !test;
});
if (node.error) doc.errors.push(node.error);
try {
if (generic) {
var res = generic.resolve(doc, node);
if (!(res instanceof _Collection.default)) res = new _Scalar.default(res);
node.resolved = res;
} else {
var str = (0, _string.resolveString)(doc, node);
if (typeof str === 'string' && tags.length > 0) {
node.resolved = this.resolveScalar(str, tags);
}
}
} catch (error) {
if (!error.source) error.source = node;
doc.errors.push(error);
node.resolved = null;
}
if (!node.resolved) return null;
if (tagName && node.tag) node.resolved.tag = tagName;
return node.resolved;
}
}, {
key: "resolveNodeWithFallback",
value: function resolveNodeWithFallback(doc, node, tagName) {
var res = this.resolveNode(doc, node, tagName);
if (Object.prototype.hasOwnProperty.call(node, 'resolved')) return res;
var fallback = isMap(node) ? Schema.defaultTags.MAP : isSeq(node) ? Schema.defaultTags.SEQ : Schema.defaultTags.STR;
if (fallback) {
doc.warnings.push(new _errors.YAMLWarning(node, "The tag ".concat(tagName, " is unavailable, falling back to ").concat(fallback)));
var _res = this.resolveNode(doc, node, fallback);
_res.tag = tagName;
return _res;
} else {
doc.errors.push(new _errors.YAMLReferenceError(node, "The tag ".concat(tagName, " is unavailable")));
}
return null;
}
}, {
key: "getTagObject",
value: function getTagObject(item) {
if (item instanceof _Alias.default) return _Alias.default;
if (item.tag) {
var match = this.tags.filter(function (t) {
return t.tag === item.tag;
});
if (match.length > 0) return match.find(function (t) {
return t.format === item.format;
}) || match[0];
}
var tagObj, obj;
if (item instanceof _Scalar.default) {
obj = item.value; // TODO: deprecate/remove class check
var _match = this.tags.filter(function (t) {
return t.identify && t.identify(obj) || t.class && obj instanceof t.class;
});
tagObj = _match.find(function (t) {
return t.format === item.format;
}) || _match.find(function (t) {
return !t.format;
});
} else {
obj = item;
tagObj = this.tags.find(function (t) {
return t.nodeClass && obj instanceof t.nodeClass;
});
}
if (!tagObj) {
var name = obj && obj.constructor ? obj.constructor.name : (0, _typeof2.default)(obj);
throw new Error("Tag not resolved for ".concat(name, " value"));
}
return tagObj;
} // needs to be called before stringifier to allow for circular anchor refs
}, {
key: "stringifyProps",
value: function stringifyProps(node, tagObj, _ref6) {
var anchors = _ref6.anchors,
doc = _ref6.doc;
var props = [];
var anchor = doc.anchors.getName(node);
if (anchor) {
anchors[anchor] = node;
props.push("&".concat(anchor));
}
if (node.tag) {
props.push(doc.stringifyTag(node.tag));
} else if (!tagObj.default) {
props.push(doc.stringifyTag(tagObj.tag));
}
return props.join(' ');
}
}, {
key: "stringify",
value: function stringify(item, ctx, onComment, onChompKeep) {
var tagObj;
if (!(item instanceof _Node.default)) {
var createCtx = {
aliasNodes: [],
onTagObj: function onTagObj(o) {
return tagObj = o;
},
prevObjects: []
};
item = this.createNode(item, true, null, createCtx);
var anchors = ctx.doc.anchors;
var _iteratorNormalCompletion2 = true;
var _didIteratorError2 = false;
var _iteratorError2 = undefined;
try {
for (var _iterator2 = createCtx.aliasNodes[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
var alias = _step2.value;
alias.source = alias.source.node;
var name = anchors.getName(alias.source);
if (!name) {
name = anchors.newName();
anchors.map[name] = alias.source;
}
}
} catch (err) {
_didIteratorError2 = true;
_iteratorError2 = err;
} finally {
try {
if (!_iteratorNormalCompletion2 && _iterator2.return != null) {
_iterator2.return();
}
} finally {
if (_didIteratorError2) {
throw _iteratorError2;
}
}
}
}
ctx.tags = this;
if (item instanceof _Pair.default) return item.toString(ctx, onComment, onChompKeep);
if (!tagObj) tagObj = this.getTagObject(item);
var props = this.stringifyProps(item, tagObj, ctx);
var str = typeof tagObj.stringify === 'function' ? tagObj.stringify(item, ctx, onComment, onChompKeep) : item instanceof _Collection.default ? item.toString(ctx, onComment, onChompKeep) : (0, _stringify.stringifyString)(item, ctx, onComment, onChompKeep);
return props ? item instanceof _Collection.default && str[0] !== '{' && str[0] !== '[' ? "".concat(props, "\n").concat(ctx.indent).concat(str) : "".concat(props, " ").concat(str) : str;
}
}]);
return Schema;
}();
exports.default = Schema;
(0, _defineProperty2.default)(Schema, "defaultPrefix", 'tag:yaml.org,2002:');
(0, _defineProperty2.default)(Schema, "defaultTags", {
MAP: 'tag:yaml.org,2002:map',
SEQ: 'tag:yaml.org,2002:seq',
STR: 'tag:yaml.org,2002:str'
});