325 lines
8.1 KiB
JavaScript
325 lines
8.1 KiB
JavaScript
"use strict";
|
|
|
|
const parsimmon = require("parsimmon");
|
|
|
|
// Turn escaped characters into real ones (e.g. "\\n" becomes "\n").
|
|
function interpretEscapes(str) {
|
|
let escapes = {
|
|
b: "\b",
|
|
f: "\f",
|
|
n: "\n",
|
|
r: "\r",
|
|
t: "\t"
|
|
};
|
|
return str.replace(/\\(u[0-9a-fA-F]{4}|[^u])/, (_, escape) => {
|
|
let type = escape.charAt(0);
|
|
let hex = escape.slice(1);
|
|
if (type === "u") return String.fromCharCode(parseInt(hex, 16));
|
|
|
|
if (escapes.hasOwnProperty(type)) return escapes[type];
|
|
|
|
return type;
|
|
});
|
|
}
|
|
|
|
function binaryLeft(operatorsParser, nextParser) {
|
|
return parsimmon.seqMap(
|
|
nextParser,
|
|
parsimmon.seq(operatorsParser, nextParser).many(),
|
|
(first, rest) =>
|
|
rest.reduce((acc, ch) => {
|
|
let [op, another] = ch;
|
|
if (op === acc[0]) return acc.concat([another]);
|
|
if (op === another[0]) return [op, acc].concat(another.slice(1));
|
|
return [op, acc, another];
|
|
}, first)
|
|
);
|
|
}
|
|
|
|
const lang = parsimmon.createLanguage({
|
|
ComparisonOperator: function() {
|
|
return parsimmon
|
|
.alt(
|
|
parsimmon.string(">="),
|
|
parsimmon.string("<>"),
|
|
parsimmon.string("<="),
|
|
parsimmon.string("="),
|
|
parsimmon.string(">"),
|
|
parsimmon.string("<")
|
|
)
|
|
.skip(parsimmon.optWhitespace);
|
|
},
|
|
IsNullOperator: function() {
|
|
return parsimmon
|
|
.alt(
|
|
parsimmon
|
|
.regexp(/is\s+null/i)
|
|
.result("IS NULL")
|
|
.desc("IS NULL"),
|
|
parsimmon
|
|
.regexp(/is\s+not\s+null/i)
|
|
.result("IS NOT NULL")
|
|
.desc("IS NOT NULL")
|
|
)
|
|
.skip(parsimmon.optWhitespace);
|
|
},
|
|
NotOperator: function() {
|
|
return parsimmon
|
|
.regexp(/not/i)
|
|
.result("NOT")
|
|
.skip(parsimmon.optWhitespace)
|
|
.desc("NOT");
|
|
},
|
|
AndOperator: function() {
|
|
return parsimmon
|
|
.regexp(/and/i)
|
|
.result("AND")
|
|
.skip(parsimmon.optWhitespace)
|
|
.desc("AND");
|
|
},
|
|
OrOperator: function() {
|
|
return parsimmon
|
|
.regexp(/or/i)
|
|
.result("OR")
|
|
.skip(parsimmon.optWhitespace)
|
|
.desc("OR");
|
|
},
|
|
Parameter: function(r) {
|
|
return parsimmon
|
|
.alt(
|
|
parsimmon.regexp(/[a-zA-Z0-9_.*]+/),
|
|
r.ValueExpression.wrap(
|
|
parsimmon.string("{").skip(parsimmon.optWhitespace),
|
|
parsimmon.string("}")
|
|
)
|
|
)
|
|
.atLeast(1)
|
|
.map(x => (x.length > 1 ? ["||"].concat(x) : x[0]))
|
|
.skip(parsimmon.optWhitespace)
|
|
.desc("parameter");
|
|
},
|
|
StringValueSql: function() {
|
|
return parsimmon
|
|
.regexp(/'([^']*)'/, 1)
|
|
.atLeast(1)
|
|
.skip(parsimmon.optWhitespace)
|
|
.map(s => s.join("'"))
|
|
.desc("string");
|
|
},
|
|
StringValueJs: function() {
|
|
return parsimmon
|
|
.regexp(/"((?:\\.|.)*?)"/, 1)
|
|
.skip(parsimmon.optWhitespace)
|
|
.map(interpretEscapes)
|
|
.desc("string");
|
|
},
|
|
NumberValue: function() {
|
|
return parsimmon
|
|
.regexp(/-?(0|[1-9][0-9]*)([.][0-9]+)?([eE][+-]?[0-9]+)?/)
|
|
.skip(parsimmon.optWhitespace)
|
|
.map(Number)
|
|
.desc("number");
|
|
},
|
|
FuncValue: function(r) {
|
|
return parsimmon.seqMap(
|
|
parsimmon
|
|
.regexp(/([a-zA-Z0-0_]+)/, 1)
|
|
.skip(parsimmon.optWhitespace)
|
|
.desc("function"),
|
|
r.Value.sepBy(parsimmon.string(",").skip(parsimmon.optWhitespace)).wrap(
|
|
parsimmon.string("(").skip(parsimmon.optWhitespace),
|
|
parsimmon.string(")").skip(parsimmon.optWhitespace)
|
|
),
|
|
(f, args) => ["FUNC", f.toUpperCase()].concat(args)
|
|
);
|
|
},
|
|
Value: function(r) {
|
|
return parsimmon.alt(
|
|
r.NumberValue,
|
|
r.StringValueSql,
|
|
r.StringValueJs,
|
|
r.FuncValue
|
|
);
|
|
},
|
|
ValueExpression: function(r) {
|
|
return binaryLeft(
|
|
parsimmon.string("||"),
|
|
binaryLeft(
|
|
parsimmon
|
|
.alt(parsimmon.string("+"), parsimmon.string("-"))
|
|
.skip(parsimmon.optWhitespace),
|
|
binaryLeft(
|
|
parsimmon
|
|
.alt(parsimmon.string("*"), parsimmon.string("/"))
|
|
.skip(parsimmon.optWhitespace),
|
|
parsimmon.alt(
|
|
r.Value,
|
|
r.ValueExpression.wrap(
|
|
parsimmon.string("(").skip(parsimmon.optWhitespace),
|
|
parsimmon.string(")").skip(parsimmon.optWhitespace)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
);
|
|
},
|
|
Comparison: function(r) {
|
|
return parsimmon.alt(
|
|
parsimmon.seqMap(r.Parameter, r.IsNullOperator, (p, o) => [o, p]),
|
|
parsimmon.seqMap(
|
|
r.Parameter,
|
|
r.ComparisonOperator,
|
|
r.ValueExpression,
|
|
(p, o, v) => [o, p, v]
|
|
)
|
|
);
|
|
},
|
|
Expression: function(r) {
|
|
function unary(operatorsParser, nextParser) {
|
|
return parsimmon.seq(operatorsParser, nextParser).or(nextParser);
|
|
}
|
|
|
|
return binaryLeft(
|
|
r.OrOperator,
|
|
binaryLeft(
|
|
r.AndOperator,
|
|
unary(
|
|
r.NotOperator,
|
|
r.Comparison.or(
|
|
r.Expression.wrap(
|
|
parsimmon.string("("),
|
|
parsimmon.string(")").skip(parsimmon.optWhitespace)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
).trim(parsimmon.optWhitespace);
|
|
}
|
|
});
|
|
|
|
function parse(filter) {
|
|
return lang.Expression.tryParse(filter);
|
|
}
|
|
|
|
function parseExpression(exp) {
|
|
return lang.ValueExpression.tryParse(exp);
|
|
}
|
|
|
|
function parseParameter(p) {
|
|
return lang.Parameter.tryParse(p);
|
|
}
|
|
|
|
function stringify(filter) {
|
|
function value(v) {
|
|
if (Array.isArray(v))
|
|
if (v[0].toUpperCase() === "FUNC") {
|
|
return `${v[1]}(${v
|
|
.slice(2)
|
|
.map(e => value(e))
|
|
.join(", ")})`;
|
|
} else {
|
|
return v
|
|
.slice(1)
|
|
.map(e => value(e))
|
|
.join(` ${v[0]} `);
|
|
}
|
|
|
|
return JSON.stringify(v);
|
|
}
|
|
|
|
function expressions(v) {
|
|
return v.map(e => {
|
|
let str = stringify(e);
|
|
if (e[0] === "AND" || e[0] === "OR") return `(${str})`;
|
|
else return str;
|
|
});
|
|
}
|
|
|
|
function parameter(v) {
|
|
if (Array.isArray(v) && v[0] === "||")
|
|
return v
|
|
.slice(1)
|
|
.map(x => {
|
|
if (Array.isArray(x)) return `{${value(x)}}`;
|
|
else return x;
|
|
})
|
|
.join("");
|
|
|
|
return v;
|
|
}
|
|
|
|
const op = filter[0].toUpperCase();
|
|
|
|
if (["AND", "OR"].includes(op))
|
|
return expressions(filter.slice(1)).join(` ${op} `);
|
|
else if (op === "NOT") return `NOT ${expressions(filter.slice(1))[0]}`;
|
|
else if ([">=", "<>", "<=", "=", ">", "<"].includes(op))
|
|
return `${parameter(filter[1])} ${op} ${value(filter[2])}`;
|
|
else if (["IS NULL", "IS NOT NULL"].includes(op))
|
|
return `${parameter(filter[1])} ${op}`;
|
|
else throw new Error("Unrecognized operator");
|
|
}
|
|
|
|
function map(filter, callback) {
|
|
let clone;
|
|
for (let i = 1; i < filter.length; ++i)
|
|
if (Array.isArray(filter[i])) {
|
|
let sub = map(filter[i], callback);
|
|
if (sub != null && sub !== filter[i]) {
|
|
clone = clone || filter.slice();
|
|
clone[i] = sub;
|
|
}
|
|
}
|
|
|
|
return callback(clone || filter) || clone || filter;
|
|
}
|
|
|
|
function and(filter1, filter2) {
|
|
if (!filter1) return filter2;
|
|
else if (!filter2) return filter1;
|
|
|
|
let res = ["AND"];
|
|
|
|
if (filter1[0] === "AND") res = res.concat(filter1.slice(1));
|
|
else res.push(filter1);
|
|
|
|
if (filter2[0] === "AND") res = res.concat(filter2.slice(1));
|
|
else res.push(filter2);
|
|
|
|
return res;
|
|
}
|
|
|
|
function evaluateExpressions(filter, now = Date.now()) {
|
|
return map(filter, exp => {
|
|
if (exp[0] === "FUNC" && exp[1] === "NOW") {
|
|
return now;
|
|
} else if (exp[0] === "*") {
|
|
let v = exp[1];
|
|
for (let i = 2; i < exp.length; ++i) v *= exp[i];
|
|
return v;
|
|
} else if (exp[0] === "/") {
|
|
let v = exp[1];
|
|
for (let i = 2; i < exp.length; ++i) v /= exp[i];
|
|
return v;
|
|
} else if (exp[0] === "+") {
|
|
let v = exp[1];
|
|
for (let i = 2; i < exp.length; ++i) v += exp[i];
|
|
return v;
|
|
} else if (exp[0] === "-") {
|
|
let v = exp[1];
|
|
for (let i = 2; i < exp.length; ++i) v -= exp[i];
|
|
return v;
|
|
} else if (exp[0] === "||") {
|
|
return exp.slice(1).join("");
|
|
}
|
|
});
|
|
}
|
|
|
|
exports.parse = parse;
|
|
exports.parseExpression = parseExpression;
|
|
exports.parseParameter = parseParameter;
|
|
exports.stringify = stringify;
|
|
exports.map = map;
|
|
exports.and = and;
|
|
exports.evaluateExpressions = evaluateExpressions;
|