twig
Version:
JS port of the Twig templating language.
1,270 lines (1,124 loc) • 54.6 kB
JavaScript
// ## twig.expression.js
//
// This file handles tokenizing, compiling and parsing expressions.
module.exports = function (Twig) {
'use strict';
function parseParams(state, params, context) {
if (params) {
return Twig.expression.parseAsync.call(state, params, context);
}
return Twig.Promise.resolve(false);
}
/**
* Namespace for expression handling.
*/
Twig.expression = { };
require('./twig.expression.operator')(Twig);
/**
* Reserved word that can't be used as variable names.
*/
Twig.expression.reservedWords = [
'true', 'false', 'null', 'TRUE', 'FALSE', 'NULL', '_context', 'and', 'b-and', 'or', 'b-or', 'b-xor', 'in', 'not in', 'if', 'matches', 'starts', 'ends', 'with'
];
/**
* The type of tokens used in expressions.
*/
Twig.expression.type = {
comma: 'Twig.expression.type.comma',
operator: {
unary: 'Twig.expression.type.operator.unary',
binary: 'Twig.expression.type.operator.binary'
},
string: 'Twig.expression.type.string',
bool: 'Twig.expression.type.bool',
slice: 'Twig.expression.type.slice',
array: {
start: 'Twig.expression.type.array.start',
end: 'Twig.expression.type.array.end'
},
object: {
start: 'Twig.expression.type.object.start',
end: 'Twig.expression.type.object.end'
},
parameter: {
start: 'Twig.expression.type.parameter.start',
end: 'Twig.expression.type.parameter.end'
},
subexpression: {
start: 'Twig.expression.type.subexpression.start',
end: 'Twig.expression.type.subexpression.end'
},
key: {
period: 'Twig.expression.type.key.period',
brackets: 'Twig.expression.type.key.brackets'
},
filter: 'Twig.expression.type.filter',
_function: 'Twig.expression.type._function',
variable: 'Twig.expression.type.variable',
number: 'Twig.expression.type.number',
_null: 'Twig.expression.type.null',
context: 'Twig.expression.type.context',
test: 'Twig.expression.type.test'
};
Twig.expression.set = {
// What can follow an expression (in general)
operations: [
Twig.expression.type.filter,
Twig.expression.type.operator.unary,
Twig.expression.type.operator.binary,
Twig.expression.type.array.end,
Twig.expression.type.object.end,
Twig.expression.type.parameter.end,
Twig.expression.type.subexpression.end,
Twig.expression.type.comma,
Twig.expression.type.test
],
expressions: [
Twig.expression.type._function,
Twig.expression.type.bool,
Twig.expression.type.string,
Twig.expression.type.variable,
Twig.expression.type.number,
Twig.expression.type._null,
Twig.expression.type.context,
Twig.expression.type.parameter.start,
Twig.expression.type.array.start,
Twig.expression.type.object.start,
Twig.expression.type.subexpression.start,
Twig.expression.type.operator.unary
]
};
// Most expressions allow a '.' or '[' after them, so we provide a convenience set
Twig.expression.set.operationsExtended = Twig.expression.set.operations.concat([
Twig.expression.type.key.period,
Twig.expression.type.key.brackets,
Twig.expression.type.slice
]);
// Some commonly used compile and parse functions.
Twig.expression.fn = {
compile: {
push(token, stack, output) {
output.push(token);
},
pushBoth(token, stack, output) {
output.push(token);
stack.push(token);
}
},
parse: {
push(token, stack) {
stack.push(token);
},
pushValue(token, stack) {
stack.push(token.value);
}
}
};
// The regular expressions and compile/parse logic used to match tokens in expressions.
//
// Properties:
//
// type: The type of expression this matches
//
// regex: One or more regular expressions that matche the format of the token.
//
// next: Valid tokens that can occur next in the expression.
//
// Functions:
//
// compile: A function that compiles the raw regular expression match into a token.
//
// parse: A function that parses the compiled token into output.
//
Twig.expression.definitions = [
{
type: Twig.expression.type.test,
regex: /^is\s+(not)?\s*([a-zA-Z_]\w*(\s?(?:as|by))?)/,
next: Twig.expression.set.operations.concat([Twig.expression.type.parameter.start]),
compile(token, stack, output) {
token.filter = token.match[2];
token.modifier = token.match[1];
delete token.match;
delete token.value;
output.push(token);
},
parse(token, stack, context) {
const value = stack.pop();
const state = this;
return parseParams(state, token.params, context)
.then(params => {
const result = Twig.test(token.filter, value, params);
if (token.modifier === 'not') {
stack.push(!result);
} else {
stack.push(result);
}
});
}
},
{
type: Twig.expression.type.comma,
// Match a comma
regex: /^,/,
next: Twig.expression.set.expressions.concat([Twig.expression.type.array.end, Twig.expression.type.object.end]),
compile(token, stack, output) {
let i = stack.length - 1;
let stackToken;
delete token.match;
delete token.value;
// Pop tokens off the stack until the start of the object
for (;i >= 0; i--) {
stackToken = stack.pop();
if (stackToken.type === Twig.expression.type.object.start ||
stackToken.type === Twig.expression.type.parameter.start ||
stackToken.type === Twig.expression.type.array.start) {
stack.push(stackToken);
break;
}
output.push(stackToken);
}
output.push(token);
}
},
{
/**
* Match a number (integer or decimal)
*/
type: Twig.expression.type.number,
// Match a number
regex: /^-?\d+(\.\d+)?/,
next: Twig.expression.set.operations,
compile(token, stack, output) {
token.value = Number(token.value);
output.push(token);
},
parse: Twig.expression.fn.parse.pushValue
},
{
type: Twig.expression.type.operator.binary,
// Match any of ??, ?:, +, *, /, -, %, ~, <=>, <, <=, >, >=, !=, ==, **, ?, :, and, b-and, or, b-or, b-xor, in, not in
// and, or, in, not in, matches, starts with, ends with can be followed by a space or parenthesis
regex: /(^\?\?|^\?\s*:|^(b-and)|^(b-or)|^(b-xor)|^[+\-~%?]|^(<=>)|^[:](?!\d\])|^[!=]==?|^[!<>]=?|^\*\*?|^\/\/?|^(and)[(|\s+]|^(or)[(|\s+]|^(in)[(|\s+]|^(not in)[(|\s+]|^(matches)|^(starts with)|^(ends with)|^\.\.)/,
next: Twig.expression.set.expressions,
transform(match, tokens) {
switch (match[0]) {
case 'and(':
case 'or(':
case 'in(':
case 'not in(':
// Strip off the ( if it exists
tokens[tokens.length - 1].value = match[2];
return match[0];
default:
return '';
}
},
compile(token, stack, output) {
delete token.match;
if (token.value.match(/^\?\s*:/)) {
token.value = '?:';
}
token.value = token.value.trim();
const {value} = token;
const operator = Twig.expression.operator.lookup(value, token);
Twig.log.trace('Twig.expression.compile: ', 'Operator: ', operator, ' from ', value);
while (stack.length > 0 &&
(stack[stack.length - 1].type === Twig.expression.type.operator.unary || stack[stack.length - 1].type === Twig.expression.type.operator.binary) &&
(
(operator.associativity === Twig.expression.operator.leftToRight &&
operator.precidence >= stack[stack.length - 1].precidence) ||
(operator.associativity === Twig.expression.operator.rightToLeft &&
operator.precidence > stack[stack.length - 1].precidence)
)
) {
const temp = stack.pop();
output.push(temp);
}
if (value === ':') {
// Check if this is a ternary or object key being set
if (stack[stack.length - 1] && stack[stack.length - 1].value === '?') {
// Continue as normal for a ternary
} else {
// This is not a ternary so we push the token to the output where it can be handled
// when the assocated object is closed.
const keyToken = output.pop();
if (keyToken.type === Twig.expression.type.string ||
keyToken.type === Twig.expression.type.variable) {
token.key = keyToken.value;
} else if (keyToken.type === Twig.expression.type.number) {
// Convert integer keys into string keys
token.key = keyToken.value.toString();
} else if (keyToken.expression &&
(keyToken.type === Twig.expression.type.parameter.end ||
keyToken.type === Twig.expression.type.subexpression.end)) {
token.params = keyToken.params;
} else {
throw new Twig.Error('Unexpected value before \':\' of ' + keyToken.type + ' = ' + keyToken.value);
}
output.push(token);
}
} else {
stack.push(operator);
}
},
parse(token, stack, context) {
const state = this;
if (token.key) {
// Handle ternary ':' operator
stack.push(token);
} else if (token.params) {
// Handle "{(expression):value}"
return Twig.expression.parseAsync.call(state, token.params, context)
.then(key => {
token.key = key;
stack.push(token);
// If we're in a loop, we might need token.params later, especially in this form of "(expression):value"
if (!context.loop) {
delete (token.params);
}
});
} else {
Twig.expression.operator.parse(token.value, stack);
}
}
},
{
type: Twig.expression.type.operator.unary,
// Match any of not
regex: /(^not\s+)/,
next: Twig.expression.set.expressions,
compile(token, stack, output) {
delete token.match;
token.value = token.value.trim();
const {value} = token;
const operator = Twig.expression.operator.lookup(value, token);
Twig.log.trace('Twig.expression.compile: ', 'Operator: ', operator, ' from ', value);
while (stack.length > 0 &&
(stack[stack.length - 1].type === Twig.expression.type.operator.unary || stack[stack.length - 1].type === Twig.expression.type.operator.binary) &&
(
(operator.associativity === Twig.expression.operator.leftToRight &&
operator.precidence >= stack[stack.length - 1].precidence) ||
(operator.associativity === Twig.expression.operator.rightToLeft &&
operator.precidence > stack[stack.length - 1].precidence)
)
) {
const temp = stack.pop();
output.push(temp);
}
stack.push(operator);
},
parse(token, stack) {
Twig.expression.operator.parse(token.value, stack);
}
},
{
/**
* Match a string. This is anything between a pair of single or double quotes.
*/
type: Twig.expression.type.string,
// See: http://blog.stevenlevithan.com/archives/match-quoted-string
regex: /^(["'])(?:(?=(\\?))\2[\s\S])*?\1/,
next: Twig.expression.set.operationsExtended,
compile(token, stack, output) {
let {value} = token;
delete token.match;
// Remove the quotes from the string
if (value.slice(0, 1) === '"') {
value = value.replace('\\"', '"');
} else {
value = value.replace('\\\'', '\'');
}
token.value = value.slice(1, -1).replace(/\\n/g, '\n').replace(/\\r/g, '\r');
Twig.log.trace('Twig.expression.compile: ', 'String value: ', token.value);
output.push(token);
},
parse: Twig.expression.fn.parse.pushValue
},
{
/**
* Match a subexpression set start.
*/
type: Twig.expression.type.subexpression.start,
regex: /^\(/,
next: Twig.expression.set.expressions.concat([Twig.expression.type.subexpression.end]),
compile(token, stack, output) {
token.value = '(';
output.push(token);
stack.push(token);
},
parse: Twig.expression.fn.parse.push
},
{
/**
* Match a subexpression set end.
*/
type: Twig.expression.type.subexpression.end,
regex: /^\)/,
next: Twig.expression.set.operationsExtended,
validate(match, tokens) {
// Iterate back through previous tokens to ensure we follow a subexpression start
let i = tokens.length - 1;
let foundSubexpressionStart = false;
let nextSubexpressionStartInvalid = false;
let unclosedParameterCount = 0;
while (!foundSubexpressionStart && i >= 0) {
const token = tokens[i];
foundSubexpressionStart = token.type === Twig.expression.type.subexpression.start;
// If we have previously found a subexpression end, then this subexpression start is the start of
// that subexpression, not the subexpression we are searching for
if (foundSubexpressionStart && nextSubexpressionStartInvalid) {
nextSubexpressionStartInvalid = false;
foundSubexpressionStart = false;
}
// Count parameter tokens to ensure we dont return truthy for a parameter opener
if (token.type === Twig.expression.type.parameter.start) {
unclosedParameterCount++;
} else if (token.type === Twig.expression.type.parameter.end) {
unclosedParameterCount--;
} else if (token.type === Twig.expression.type.subexpression.end) {
nextSubexpressionStartInvalid = true;
}
i--;
}
// If we found unclosed parameters, return false
// If we didnt find subexpression start, return false
// Otherwise return true
return (foundSubexpressionStart && (unclosedParameterCount === 0));
},
compile(token, stack, output) {
// This is basically a copy of parameter end compilation
let stackToken;
const endToken = token;
stackToken = stack.pop();
while (stack.length > 0 && stackToken.type !== Twig.expression.type.subexpression.start) {
output.push(stackToken);
stackToken = stack.pop();
}
// Move contents of parens into preceding filter
const paramStack = [];
while (token.type !== Twig.expression.type.subexpression.start) {
// Add token to arguments stack
paramStack.unshift(token);
token = output.pop();
}
paramStack.unshift(token);
// If the token at the top of the *stack* is a function token, pop it onto the output queue.
// Get the token preceding the parameters
stackToken = stack[stack.length - 1];
if (stackToken === undefined ||
(stackToken.type !== Twig.expression.type._function &&
stackToken.type !== Twig.expression.type.filter &&
stackToken.type !== Twig.expression.type.test &&
stackToken.type !== Twig.expression.type.key.brackets)) {
endToken.expression = true;
// Remove start and end token from stack
paramStack.pop();
paramStack.shift();
endToken.params = paramStack;
output.push(endToken);
} else {
// This should never be hit
endToken.expression = false;
stackToken.params = paramStack;
}
},
parse(token, stack, context) {
const state = this;
if (token.expression) {
return Twig.expression.parseAsync.call(state, token.params, context)
.then(value => {
stack.push(value);
});
}
throw new Twig.Error('Unexpected subexpression end when token is not marked as an expression');
}
},
{
/**
* Match a parameter set start.
*/
type: Twig.expression.type.parameter.start,
regex: /^\(/,
next: Twig.expression.set.expressions.concat([Twig.expression.type.parameter.end]),
validate(match, tokens) {
const lastToken = tokens[tokens.length - 1];
// We can't use the regex to test if we follow a space because expression is trimmed
return lastToken && (!Twig.expression.reservedWords.includes(lastToken.value.trim()));
},
compile: Twig.expression.fn.compile.pushBoth,
parse: Twig.expression.fn.parse.push
},
{
/**
* Match a parameter set end.
*/
type: Twig.expression.type.parameter.end,
regex: /^\)/,
next: Twig.expression.set.operationsExtended,
compile(token, stack, output) {
let stackToken;
const endToken = token;
stackToken = stack.pop();
while (stack.length > 0 && stackToken.type !== Twig.expression.type.parameter.start) {
output.push(stackToken);
stackToken = stack.pop();
}
// Move contents of parens into preceding filter
const paramStack = [];
while (token.type !== Twig.expression.type.parameter.start) {
// Add token to arguments stack
paramStack.unshift(token);
token = output.pop();
}
paramStack.unshift(token);
// Get the token preceding the parameters
token = output[output.length - 1];
if (token === undefined ||
(token.type !== Twig.expression.type._function &&
token.type !== Twig.expression.type.filter &&
token.type !== Twig.expression.type.test &&
token.type !== Twig.expression.type.key.brackets)) {
endToken.expression = true;
// Remove start and end token from stack
paramStack.pop();
paramStack.shift();
endToken.params = paramStack;
output.push(endToken);
} else {
endToken.expression = false;
token.params = paramStack;
}
},
parse(token, stack, context) {
const newArray = [];
let arrayEnded = false;
let value = null;
const state = this;
if (token.expression) {
return Twig.expression.parseAsync.call(state, token.params, context)
.then(value => {
stack.push(value);
});
}
while (stack.length > 0) {
value = stack.pop();
// Push values into the array until the start of the array
if (value && value.type && value.type === Twig.expression.type.parameter.start) {
arrayEnded = true;
break;
}
newArray.unshift(value);
}
if (!arrayEnded) {
throw new Twig.Error('Expected end of parameter set.');
}
stack.push(newArray);
}
},
{
type: Twig.expression.type.slice,
regex: /^\[(-?\w*:-?\w*)\]/,
next: Twig.expression.set.operationsExtended,
compile(token, stack, output) {
const sliceRange = token.match[1].split(':');
// SliceStart can be undefined when we pass parameters to the slice filter later
const sliceStart = sliceRange[0];
const sliceEnd = sliceRange[1];
token.value = 'slice';
token.params = [sliceStart, sliceEnd];
// SliceEnd can't be undefined as the slice filter doesn't check for this, but it does check the length
// of the params array, so just shorten it.
if (!sliceEnd) {
token.params = [sliceStart];
}
output.push(token);
},
parse(token, stack, context) {
const input = stack.pop();
let {params} = token;
const state = this;
if (parseInt(params[0], 10).toString() === params[0]) {
params[0] = parseInt(params[0], 10);
} else {
const value = context[params[0]];
if (state.template.options.strictVariables && value === undefined) {
throw new Twig.Error('Variable "' + params[0] + '" does not exist.');
}
params[0] = value;
}
if (params[1]) {
if (parseInt(params[1], 10).toString() === params[1]) {
params[1] = parseInt(params[1], 10);
} else {
const value = context[params[1]];
if (state.template.options.strictVariables && value === undefined) {
throw new Twig.Error('Variable "' + params[1] + '" does not exist.');
}
if (value === undefined) {
params = [params[0]];
} else {
params[1] = value;
}
}
}
stack.push(Twig.filter.call(state, token.value, input, params));
}
},
{
/**
* Match an array start.
*/
type: Twig.expression.type.array.start,
regex: /^\[/,
next: Twig.expression.set.expressions.concat([Twig.expression.type.array.end]),
compile: Twig.expression.fn.compile.pushBoth,
parse: Twig.expression.fn.parse.push
},
{
/**
* Match an array end.
*/
type: Twig.expression.type.array.end,
regex: /^\]/,
next: Twig.expression.set.operationsExtended,
compile(token, stack, output) {
let i = stack.length - 1;
let stackToken;
// Pop tokens off the stack until the start of the object
for (;i >= 0; i--) {
stackToken = stack.pop();
if (stackToken.type === Twig.expression.type.array.start) {
break;
}
output.push(stackToken);
}
output.push(token);
},
parse(token, stack) {
const newArray = [];
let arrayEnded = false;
let value = null;
while (stack.length > 0) {
value = stack.pop();
// Push values into the array until the start of the array
if (value && value.type && value.type === Twig.expression.type.array.start) {
arrayEnded = true;
break;
}
newArray.unshift(value);
}
if (!arrayEnded) {
throw new Twig.Error('Expected end of array.');
}
stack.push(newArray);
}
},
// Token that represents the start of a hash map '}'
//
// Hash maps take the form:
// { "key": 'value', "another_key": item }
//
// Keys must be quoted (either single or double) and values can be any expression.
{
type: Twig.expression.type.object.start,
regex: /^\{/,
next: Twig.expression.set.expressions.concat([Twig.expression.type.object.end]),
compile: Twig.expression.fn.compile.pushBoth,
parse: Twig.expression.fn.parse.push
},
// Token that represents the end of a Hash Map '}'
//
// This is where the logic for building the internal
// representation of a hash map is defined.
{
type: Twig.expression.type.object.end,
regex: /^\}/,
next: Twig.expression.set.operationsExtended,
compile(token, stack, output) {
let i = stack.length - 1;
let stackToken;
// Pop tokens off the stack until the start of the object
for (;i >= 0; i--) {
stackToken = stack.pop();
if (stackToken && stackToken.type === Twig.expression.type.object.start) {
break;
}
output.push(stackToken);
}
output.push(token);
},
parse(endToken, stack) {
const newObject = {};
let objectEnded = false;
let token = null;
let hasValue = false;
let value = null;
while (stack.length > 0) {
token = stack.pop();
// Push values into the array until the start of the object
if (token && token.type && token.type === Twig.expression.type.object.start) {
objectEnded = true;
break;
}
if (token && token.type && (token.type === Twig.expression.type.operator.binary || token.type === Twig.expression.type.operator.unary) && token.key) {
if (!hasValue) {
throw new Twig.Error('Missing value for key \'' + token.key + '\' in object definition.');
}
newObject[token.key] = value;
// Preserve the order that elements are added to the map
// This is necessary since JavaScript objects don't
// guarantee the order of keys
if (newObject._keys === undefined) {
newObject._keys = [];
}
newObject._keys.unshift(token.key);
// Reset value check
value = null;
hasValue = false;
} else {
hasValue = true;
value = token;
}
}
if (!objectEnded) {
throw new Twig.Error('Unexpected end of object.');
}
stack.push(newObject);
}
},
// Token representing a filter
//
// Filters can follow any expression and take the form:
// expression|filter(optional, args)
//
// Filter parsing is done in the Twig.filters namespace.
{
type: Twig.expression.type.filter,
// Match a | then a letter or _, then any number of letters, numbers, _ or -
regex: /^\|\s?([a-zA-Z_][a-zA-Z0-9_-]*)/,
next: Twig.expression.set.operationsExtended.concat([
Twig.expression.type.parameter.start
]),
compile(token, stack, output) {
token.value = token.match[1];
output.push(token);
},
parse(token, stack, context) {
const input = stack.pop();
const state = this;
return parseParams(state, token.params, context)
.then(params => {
return Twig.filter.call(state, token.value, input, params);
})
.then(value => {
stack.push(value);
});
}
},
{
type: Twig.expression.type._function,
// Match any letter or _, then any number of letters, numbers, _ or - followed by (
regex: /^([a-zA-Z_]\w*)\s*\(/,
next: Twig.expression.type.parameter.start,
validate(match) {
// Make sure this function is not a reserved word
return match[1] && (!Twig.expression.reservedWords.includes(match[1]));
},
transform() {
return '(';
},
compile(token, stack, output) {
const fn = token.match[1];
token.fn = fn;
// Cleanup token
delete token.match;
delete token.value;
output.push(token);
},
parse(token, stack, context) {
const state = this;
const {fn} = token;
let value;
return parseParams(state, token.params, context)
.then(params => {
if (Twig.functions[fn]) {
// Get the function from the built-in functions
value = Twig.functions[fn].apply(state, params);
} else if (typeof context[fn] === 'function') {
// Get the function from the user/context defined functions
value = context[fn](...params);
} else {
throw new Twig.Error(fn + ' function does not exist and is not defined in the context');
}
return value;
})
.then(result => {
stack.push(result);
});
}
},
// Token representing a variable.
//
// Variables can contain letters, numbers, underscores and
// dashes, but must start with a letter or underscore.
//
// Variables are retrieved from the render context and take
// the value of 'undefined' if the given variable doesn't
// exist in the context.
{
type: Twig.expression.type.variable,
// Match any letter or _, then any number of letters, numbers, _ or -
regex: /^[a-zA-Z_]\w*/,
next: Twig.expression.set.operationsExtended.concat([
Twig.expression.type.parameter.start
]),
compile: Twig.expression.fn.compile.push,
validate(match) {
return (!Twig.expression.reservedWords.includes(match[0]));
},
parse(token, stack, context) {
const state = this;
// Get the variable from the context
return Twig.expression.resolveAsync.call(state, context[token.value], context)
.then(value => {
if (state.template.options.strictVariables && value === undefined) {
throw new Twig.Error('Variable "' + token.value + '" does not exist.');
}
stack.push(value);
});
}
},
{
type: Twig.expression.type.key.period,
regex: /^\.(\w+)/,
next: Twig.expression.set.operationsExtended.concat([
Twig.expression.type.parameter.start
]),
compile(token, stack, output) {
token.key = token.match[1];
delete token.match;
delete token.value;
output.push(token);
},
parse(token, stack, context, nextToken) {
const state = this;
const {key} = token;
const object = stack.pop();
let value;
if (object && !Object.prototype.hasOwnProperty.call(object, key) && state.template.options.strictVariables) {
const keys = Object.keys(object);
if (keys.length > 0) {
throw new Twig.Error('Key "' + key + '" for object with keys "' + Object.keys(object).join(', ') + '" does not exist.');
} else {
throw new Twig.Error('Key "' + key + '" does not exist as the object is empty.');
}
}
return parseParams(state, token.params, context)
.then(params => {
if (object === null || object === undefined) {
value = undefined;
} else {
const capitalize = function (value) {
return value.slice(0, 1).toUpperCase() + value.slice(1);
};
// Get the variable from the context
if (typeof object === 'object' && key in object) {
value = object[key];
} else if (object['get' + capitalize(key)]) {
value = object['get' + capitalize(key)];
} else if (object['is' + capitalize(key)]) {
value = object['is' + capitalize(key)];
} else {
value = undefined;
}
}
// When resolving an expression we need to pass nextToken in case the expression is a function
return Twig.expression.resolveAsync.call(state, value, context, params, nextToken, object);
})
.then(result => {
stack.push(result);
});
}
},
{
type: Twig.expression.type.key.brackets,
regex: /^\[([^\]]*)\]/,
next: Twig.expression.set.operationsExtended.concat([
Twig.expression.type.parameter.start
]),
compile(token, stack, output) {
const match = token.match[1];
delete token.value;
delete token.match;
// The expression stack for the key
token.stack = Twig.expression.compile({
value: match
}).stack;
output.push(token);
},
parse(token, stack, context, nextToken) {
// Evaluate key
const state = this;
let params = null;
let object;
let value;
return parseParams(state, token.params, context)
.then(parameters => {
params = parameters;
return Twig.expression.parseAsync.call(state, token.stack, context);
})
.then(key => {
object = stack.pop();
if (object && !Object.prototype.hasOwnProperty.call(object, key) && state.template.options.strictVariables) {
const keys = Object.keys(object);
if (keys.length > 0) {
throw new Twig.Error('Key "' + key + '" for array with keys "' + keys.join(', ') + '" does not exist.');
} else {
throw new Twig.Error('Key "' + key + '" does not exist as the array is empty.');
}
} else if (object === null || object === undefined) {
return null;
}
// Get the variable from the context
if (typeof object === 'object' && key in object) {
value = object[key];
} else {
value = null;
}
// When resolving an expression we need to pass nextToken in case the expression is a function
return Twig.expression.resolveAsync.call(state, value, object, params, nextToken);
})
.then(result => {
stack.push(result);
});
}
},
{
/**
* Match a null value.
*/
type: Twig.expression.type._null,
// Match a number
regex: /^(null|NULL|none|NONE)/,
next: Twig.expression.set.operations,
compile(token, stack, output) {
delete token.match;
token.value = null;
output.push(token);
},
parse: Twig.expression.fn.parse.pushValue
},
{
/**
* Match the context
*/
type: Twig.expression.type.context,
regex: /^_context/,
next: Twig.expression.set.operationsExtended.concat([
Twig.expression.type.parameter.start
]),
compile: Twig.expression.fn.compile.push,
parse(token, stack, context) {
stack.push(context);
}
},
{
/**
* Match a boolean
*/
type: Twig.expression.type.bool,
regex: /^(true|TRUE|false|FALSE)/,
next: Twig.expression.set.operations,
compile(token, stack, output) {
token.value = (token.match[0].toLowerCase() === 'true');
delete token.match;
output.push(token);
},
parse: Twig.expression.fn.parse.pushValue
}
];
/**
* Resolve a context value.
*
* If the value is a function, it is executed with a context parameter.
*
* @param {string} key The context object key.
* @param {Object} context The render context.
*/
Twig.expression.resolveAsync = function (value, context, params, nextToken, object) {
const state = this;
if (typeof value !== 'function') {
return Twig.Promise.resolve(value);
}
let promise = Twig.Promise.resolve(params);
/*
If value is a function, it will have been impossible during the compile stage to determine that a following
set of parentheses were parameters for this function.
Those parentheses will have therefore been marked as an expression, with their own parameters, which really
belong to this function.
Those parameters will also need parsing in case they are actually an expression to pass as parameters.
*/
if (nextToken && nextToken.type === Twig.expression.type.parameter.end) {
// When parsing these parameters, we need to get them all back, not just the last item on the stack.
const tokensAreParameters = true;
promise = promise.then(() => {
return nextToken.params && Twig.expression.parseAsync.call(state, nextToken.params, context, tokensAreParameters);
})
.then(p => {
// Clean up the parentheses tokens on the next loop
nextToken.cleanup = true;
return p;
});
}
return promise.then(params => {
return value.apply(object || context, params || []);
});
};
Twig.expression.resolve = function (value, context, params, nextToken, object) {
return Twig.async.potentiallyAsync(this, false, function () {
return Twig.expression.resolveAsync.call(this, value, context, params, nextToken, object);
});
};
/**
* Registry for logic handlers.
*/
Twig.expression.handler = {};
/**
* Define a new expression type, available at Twig.logic.type.{type}
*
* @param {string} type The name of the new type.
*/
Twig.expression.extendType = function (type) {
Twig.expression.type[type] = 'Twig.expression.type.' + type;
};
/**
* Extend the expression parsing functionality with a new definition.
*
* Token definitions follow this format:
* {
* type: One of Twig.expression.type.[type], either pre-defined or added using
* Twig.expression.extendType
*
* next: Array of types from Twig.expression.type that can follow this token,
*
* regex: A regex or array of regex's that should match the token.
*
* compile: function(token, stack, output) called when this token is being compiled.
* Should return an object with stack and output set.
*
* parse: function(token, stack, context) called when this token is being parsed.
* Should return an object with stack and context set.
* }
*
* @param {Object} definition A token definition.
*/
Twig.expression.extend = function (definition) {
if (!definition.type) {
throw new Twig.Error('Unable to extend logic definition. No type provided for ' + definition);
}
Twig.expression.handler[definition.type] = definition;
};
// Extend with built-in expressions
while (Twig.expression.definitions.length > 0) {
Twig.expression.extend(Twig.expression.definitions.shift());
}
/**
* Break an expression into tokens defined in Twig.expression.definitions.
*
* @param {Object} rawToken The string to tokenize.
*
* @return {Array} An array of tokens.
*/
Twig.expression.tokenize = function (rawToken) {
let expression = rawToken.value;
const tokens = [];
// Keep an offset of the location in the expression for error messages.
let expOffset = 0;
// The valid next tokens of the previous token
let next = null;
// Match information
let type;
let regex;
let regexI;
// The possible next token for the match
let tokenNext;
// Has a match been found from the definitions
let matchFound;
let invalidMatches = [];
const matchFunction = function (...args) {
// Don't pass arguments to `Array.slice`, that is a performance killer
let matchI = arguments.length - 2;
const match = new Array(matchI);
while (matchI-- > 0) {
match[matchI] = args[matchI];
}
Twig.log.trace('Twig.expression.tokenize',
'Matched a ', type, ' regular expression of ', match);
if (next && !next.includes(type)) {
invalidMatches.push(
type + ' cannot follow a ' + tokens[tokens.length - 1].type +
' at template:' + expOffset + ' near \'' + match[0].slice(0, 20) +
'...\''
);
// Not a match, don't change the expression
return match[0];
}
const handler = Twig.expression.handler[type];
// Validate the token if a validation function is provided
if (handler.validate && !handler.validate(match, tokens)) {
return match[0];
}
invalidMatches = [];
const token = {
type,
value: match[0],
match
};
if (rawToken.position) {
token.position = rawToken.position;
}
tokens.push(token);
matchFound = true;
next = tokenNext;
expOffset += match[0].length;
// Does the token need to return output back to the expression string
// e.g. a function match of cycle( might return the '(' back to the expression
// This allows look-ahead to differentiate between token types (e.g. functions and variable names)
if (handler.transform) {
return handler.transform(match, tokens);
}
return '';
};
Twig.log.debug('Twig.expression.tokenize', 'Tokenizing expression ', expression);
while (expression.length > 0) {
expression = expression.trim();
for (type in Twig.expression.handler) {
if (Object.hasOwnProperty.call(Twig.expression.handler, type)) {
tokenNext = Twig.expression.handler[type].next;
regex = Twig.expression.handler[type].regex;
Twig.log.trace('Checking type ', type, ' on ', expression);
matchFound = false;
if (Array.isArray(regex)) {
regexI = regex.length;
while (regexI-- > 0) {
expression = expression.replace(regex[regexI], matchFunction);
}
} else {
expression = expression.replace(regex, matchFunction);
}
// An expression token has been matched. Break the for loop and start trying to
// match the next template (if expression isn't empty.)
if (matchFound) {
break;
}
}
}
if (!matchFound) {
if (invalidMatches.length > 0) {
throw new Twig.Error(invalidMatches.join(' OR '));
} else {
throw new Twig.Error('Unable to parse \'' + expression + '\' at template position' + expOffset);
}
}
}
Twig.log.trace(