const traitName = "expandPair";
const mergeSort = require("../mergesort");
const DocUtils = require("../doc-utils");
const wrapper = require("../module-wrapper");
const {getExpandToDefault} = require("../traits");
const Errors = require("../errors");
function getUnmatchedLoopException(options) {
const location = options.location;
const t = location === "start" ? "unclosed" : "unopened";
const T = location === "start" ? "Unclosed" : "Unopened";
const err = new Errors.XTTemplateError(`${T} loop`);
const tag = options.part.value;
err.properties = {
id: `${t}_loop`,
explanation: `The loop with tag ${tag} is ${t}`,
xtag: tag,
};
return err;
}
function getClosingTagNotMatchOpeningTag(options) {
const tags = options.tags;
const err = new Errors.XTTemplateError("Closing tag does not match opening tag");
err.properties = {
id: "closing_tag_does_not_match_opening_tag",
explanation: `The tag "${tags[0].value}" is closed by the tag "${tags[1].value}"`,
openingtag: tags[0].value,
closingtag: tags[1].value,
};
return err;
}
function getOpenCountChange(part) {
switch (part.location) {
case "start":
return 1;
case "end":
return -1;
default:
throw new Error(`Location should be one of 'start' or 'end' (given : ${part.location})`);
}
}
function getPairs(traits) {
const errors = [];
const pairs = [];
if (traits.length === 0) {
return {pairs, errors};
}
let countOpen = 1;
const firstTrait = traits[0];
if (firstTrait.part.location === "start") {
for (let i = 1; i < traits.length; i++) {
const currentTrait = traits[i];
countOpen += getOpenCountChange(currentTrait.part);
if (countOpen === 0) {
if (currentTrait.part.value !== firstTrait.part.value && currentTrait.part.value !== "") {
errors.push(getClosingTagNotMatchOpeningTag({tags: [firstTrait.part, currentTrait.part]}));
}
const outer = getPairs(traits.slice(i + 1));
return {pairs: [[firstTrait, currentTrait]].concat(outer.pairs), errors: errors.concat(outer.errors)};
}
}
}
const part = firstTrait.part;
errors.push(getUnmatchedLoopException({part, location: part.location}));
const outer = getPairs(traits.slice(1));
return {pairs: outer.pairs, errors: errors.concat(outer.errors)};
}
const expandPairTrait = {
name: "ExpandPairTrait",
postparse(parsed, {getTraits, postparse}) {
let traits = getTraits(traitName, parsed);
traits = traits.map(function (trait) {
return trait || [];
});
traits = mergeSort(traits);
const {pairs, errors} = getPairs(traits);
if (errors.length >= 1) {
throw Errors.throwMultiError(errors);
}
const expandedPairs = pairs.map(function (pair) {
let expandTo = pair[0].part.expandTo;
if (expandTo === "auto") {
expandTo = getExpandToDefault(parsed.slice(pair[0].offset, pair[1].offset));
}
if (!expandTo) {
return [pair[0].offset, pair[1].offset];
}
const left = DocUtils.getLeft(parsed, expandTo, pair[0].offset);
const right = DocUtils.getRight(parsed, expandTo, pair[1].offset);
return [left, right];
});
let currentPairIndex = 0;
let innerParts;
return parsed.reduce(function (newParsed, part, i) {
const inPair = currentPairIndex < pairs.length && expandedPairs[currentPairIndex][0] <= i;
const pair = pairs[currentPairIndex];
const expandedPair = expandedPairs[currentPairIndex];
if(!inPair) {
newParsed.push(part);
return newParsed;
}
if (expandedPair[0] === i) {
innerParts = [];
}
if (pair[0].offset !== i && pair[1].offset !== i) {
innerParts.push(part);
}
if (expandedPair[1] === i) {
const basePart = parsed[pair[0].offset];
delete basePart.location;
delete basePart.expandTo;
basePart.subparsed = postparse(innerParts);
newParsed.push(basePart);
currentPairIndex++;
}
return newParsed;
}, []);
},
};
module.exports = () => wrapper(expandPairTrait);
|