134 lines
3.9 KiB
JavaScript
134 lines
3.9 KiB
JavaScript
'use strict';
|
|
|
|
class VTepLInterpreter {
|
|
constructor(parser) {
|
|
this.parser = parser;
|
|
this.data = [];
|
|
this.content = '';
|
|
}
|
|
|
|
render(data) {
|
|
let self = this;
|
|
self.data = data;
|
|
let newData = self.interpreter(self.parser.parsed);
|
|
self.data = [];
|
|
return newData[0];
|
|
}
|
|
|
|
interpreter(parsed, index = 0) {
|
|
let self = this;
|
|
let types = VParserTypes;
|
|
let tplCont = '';
|
|
for (let i = index; i < parsed.length; i++) {
|
|
let item = parsed[i],
|
|
content = item.content;
|
|
switch (item.type) {
|
|
case types.content:
|
|
tplCont += content;
|
|
break;
|
|
case types.variable:
|
|
tplCont += self.getVariable(content)
|
|
break;
|
|
case types.assign:
|
|
let data = content.split("="),
|
|
key = data.shift();
|
|
self.setVariable(data.join("=").trim(), key.trim());
|
|
break;
|
|
case types.forEach:
|
|
let d = this.handleForEach(item, parsed, i);
|
|
i = d[0];
|
|
tplCont += d[1];
|
|
break;
|
|
case types.for:
|
|
let fd = this.handleFor(item, parsed, i);
|
|
i = fd[0];
|
|
tplCont += fd[1];
|
|
break;
|
|
case types.if:
|
|
let id = this.handleIf(item, parsed, i);
|
|
i = id[0];
|
|
tplCont += id[1];
|
|
break;
|
|
case types.ifEnd:
|
|
tplCont += content;
|
|
return [tplCont, i];
|
|
case types.forEnd:
|
|
tplCont += content;
|
|
return [tplCont, i];
|
|
default:
|
|
console.warn("Invalid Type found");
|
|
break;
|
|
}
|
|
}
|
|
//this.content = tplCont;
|
|
return [tplCont, parsed.length];
|
|
}
|
|
|
|
getVariable(variable) {
|
|
if (this.data[variable]) {
|
|
return this.data[variable];
|
|
}
|
|
let split = variable.split("."),
|
|
prevVar = this.data;
|
|
for (let i = 0; i < split.length; i++) {
|
|
prevVar = prevVar[split[i]] || prevVar;
|
|
}
|
|
if (typeof prevVar === 'string') {
|
|
return prevVar;
|
|
}
|
|
return '';
|
|
}
|
|
|
|
setVariable(value, variable) {
|
|
let c = this.getVariable(value);
|
|
if (c !== '') {
|
|
value = c;
|
|
}
|
|
this.data[variable] = value;
|
|
}
|
|
|
|
handleForEach(item, parsed, i) {
|
|
let content = item.content.split(" as ");
|
|
let root = this.getVariable(content[0].trim());
|
|
let addTo = 0,
|
|
isInvalid = false;
|
|
if (root === '') {
|
|
isInvalid = true;
|
|
root = [];
|
|
}
|
|
let d = Object.keys(root),
|
|
raw = '';
|
|
for (let x of d) {
|
|
this.setVariable(root[x], content[1].trim());
|
|
let data = this.interpreter(parsed, i + 1);
|
|
addTo = data[1];
|
|
raw += data[0];
|
|
}
|
|
if (isInvalid) {
|
|
raw = '';
|
|
}
|
|
return [addTo, raw];
|
|
}
|
|
|
|
handleFor(item, parsed, ind) {
|
|
let content = item.content.split(" as "),
|
|
addTo = 0,
|
|
count = content[0].trim().split(".."),
|
|
max = parseInt(count[1]),
|
|
min = parseInt(count[0]),
|
|
newContent = '';
|
|
for (let i = min; i < max; i++) {
|
|
this.setVariable(i.toString(), content[1]);
|
|
let data = this.interpreter(parsed, ind + 1);
|
|
addTo = data[1];
|
|
newContent += data[0];
|
|
}
|
|
return [addTo, newContent];
|
|
}
|
|
|
|
handleIf(item, parsed, i) {
|
|
let data = this.interpreter(parsed, i + 1);
|
|
return [data[1], data[0]];
|
|
}
|
|
}
|