148 lines
4.3 KiB
JavaScript
148 lines
4.3 KiB
JavaScript
import {fastApply} from '@avocado/core';
|
|
|
|
import compile from './compile';
|
|
|
|
const render = (ops) => ops.reduce((rendered, op) => {
|
|
switch (op.type) {
|
|
case 'key':
|
|
return `${rendered ? `${rendered}.` : ''}${op.key}`;
|
|
case 'invoke':
|
|
return `${rendered}(${op.args.length > 0 ? '...' : ''})`;
|
|
default:
|
|
return rendered;
|
|
}
|
|
}, '');
|
|
|
|
function compileOp(op) {
|
|
let args;
|
|
if ('invoke' === op.type) {
|
|
args = op.args.map(compile);
|
|
}
|
|
return (context, previous, current) => {
|
|
switch (op.type) {
|
|
case 'key':
|
|
return current[op.key];
|
|
case 'invoke':
|
|
// Pass the context itself as the last arg.
|
|
const evaluated = args.map((fn) => fn(context)).concat(context);
|
|
// Promises are resolved transparently.
|
|
const apply = (args) => fastApply(previous, current, args);
|
|
return evaluated.some((arg) => arg instanceof Promise)
|
|
? Promise.all(evaluated).then(apply)
|
|
: apply(evaluated);
|
|
}
|
|
};
|
|
}
|
|
|
|
function disambiguateResult(value, fn) {
|
|
const apply = (value) => fn(value);
|
|
return value instanceof Promise ? value.then(apply) : apply(value);
|
|
}
|
|
|
|
function compileExpression(expression) {
|
|
if (0 === expression.ops.length) {
|
|
return () => undefined;
|
|
}
|
|
const assign = 'undefined' !== typeof expression.assign
|
|
? compile(expression.assign)
|
|
: undefined;
|
|
const ops = expression.ops.map(compileOp);
|
|
const {ops: rawOps} = expression;
|
|
return (context) => {
|
|
let previous = null;
|
|
let shorted = false;
|
|
const [first, ...rest] = ops;
|
|
return rest.reduce((current, op, index) => disambiguateResult(current, (current) => {
|
|
if (shorted) {
|
|
return undefined;
|
|
}
|
|
let next = undefined;
|
|
const isLastOp = index === ops.length - 2;
|
|
if (!isLastOp || !assign) {
|
|
if ('undefined' === typeof current) {
|
|
const rendered = render(rawOps.slice(0, index + 2));
|
|
// next = Promise.reject(new Error(`'${rendered}' is undefined`));
|
|
next = undefined;
|
|
shorted = true;
|
|
}
|
|
else {
|
|
next = op(context, previous, current);
|
|
}
|
|
}
|
|
else {
|
|
const rawOp = rawOps[index + 1];
|
|
switch (rawOp.type) {
|
|
case 'key':
|
|
if ('object' === typeof current) {
|
|
current[rawOp.key] = assign(context);
|
|
next = undefined;
|
|
}
|
|
break;
|
|
case 'invoke':
|
|
const rendered = render(rawOps.slice(0, index + 2));
|
|
// next = Promise.reject(new Error(`invalid assignment to function '${rendered}'`));
|
|
next = undefined;
|
|
break;
|
|
}
|
|
}
|
|
previous = current;
|
|
current = next;
|
|
return current;
|
|
}), context.getValue(rawOps[0].key));
|
|
};
|
|
}
|
|
|
|
function compileCondition(condition) {
|
|
const {operator} = condition;
|
|
const operands = condition.operands.map(compile);
|
|
return (context) => {
|
|
switch (operator) {
|
|
case 'is':
|
|
return operands[0](context) === operands[1](context);
|
|
case 'isnt':
|
|
return operands[0](context) !== operands[1](context);
|
|
case '>':
|
|
return operands[0](context) > operands[1](context);
|
|
case '>=':
|
|
return operands[0](context) >= operands[1](context);
|
|
case '<':
|
|
return operands[0](context) < operands[1](context);
|
|
case '<=':
|
|
return operands[0](context) <= operands[1](context);
|
|
case 'or':
|
|
if (0 === operands.length) {
|
|
return true;
|
|
}
|
|
for (let i = 0; i < operands.length; i++) {
|
|
if (!!operands[i](context)) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
case 'and':
|
|
if (0 === operands.length) {
|
|
return true;
|
|
}
|
|
for (let i = 0; i < operands.length; i++) {
|
|
if (!operands[i](context)) {
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
case 'contains':
|
|
const haystack = operands[0](context);
|
|
const needle = operands[1](context);
|
|
return -1 !== haystack.indexOf(needle);
|
|
}
|
|
};
|
|
}
|
|
|
|
export function behaviorCompilers() {
|
|
return {
|
|
condition: (condition) => compileCondition(condition),
|
|
literal: ({value}) => (context) => value,
|
|
expression: (expression) => compileExpression(expression),
|
|
expressions: ({expressions}) => () => expressions.map(compileExpression),
|
|
};
|
|
}
|