mirror of
https://github.com/Hopiu/angular.js.git
synced 2026-03-17 15:40:22 +00:00
993 lines
28 KiB
JavaScript
993 lines
28 KiB
JavaScript
'use strict';
|
||
|
||
var $parseMinErr = minErr('$parse');
|
||
|
||
// Sandboxing Angular Expressions
|
||
// ------------------------------
|
||
// Angular expressions are generally considered safe because these expressions only have direct access to $scope and
|
||
// locals. However, one can obtain the ability to execute arbitrary JS code by obtaining a reference to native JS
|
||
// functions such as the Function constructor.
|
||
//
|
||
// As an example, consider the following Angular expression:
|
||
//
|
||
// {}.toString.constructor(alert("evil JS code"))
|
||
//
|
||
// We want to prevent this type of access. For the sake of performance, during the lexing phase we disallow any "dotted"
|
||
// access to any member named "constructor".
|
||
//
|
||
// For reflective calls (a[b]) we check that the value of the lookup is not the Function constructor while evaluating
|
||
// the expression, which is a stronger but more expensive test. Since reflective calls are expensive anyway, this is not
|
||
// such a big deal compared to static dereferencing.
|
||
//
|
||
// This sandboxing technique is not perfect and doesn't aim to be. The goal is to prevent exploits against the
|
||
// expression language, but not to prevent exploits that were enabled by exposing sensitive JavaScript or browser apis
|
||
// on Scope. Exposing such objects on a Scope is never a good practice and therefore we are not even trying to protect
|
||
// against interaction with an object explicitly exposed in this way.
|
||
//
|
||
// A developer could foil the name check by aliasing the Function constructor under a different name on the scope.
|
||
//
|
||
// In general, it is not possible to access a Window object from an angular expression unless a window or some DOM
|
||
// object that has a reference to window is published onto a Scope.
|
||
|
||
function ensureSafeMemberName(name, fullExpression) {
|
||
if (name === "constructor") {
|
||
throw $parseMinErr('isecfld',
|
||
'Referencing "constructor" field in Angular expressions is disallowed! Expression: {0}', fullExpression);
|
||
}
|
||
return name;
|
||
};
|
||
|
||
function ensureSafeObject(obj, fullExpression) {
|
||
// nifty check if obj is Function that is fast and works across iframes and other contexts
|
||
if (obj && obj.constructor === obj) {
|
||
throw $parseMinErr('isecfn',
|
||
'Referencing Function in Angular expressions is disallowed! Expression: {0}', fullExpression);
|
||
//
|
||
} else if (// isWindow(obj)
|
||
obj && obj.document && obj.location && obj.alert && obj.setInterval) {
|
||
throw $parseMinErr('isecwindow',
|
||
'Referencing the Window in Angular expressions is disallowed! Expression: {0}', fullExpression);
|
||
} else if (// isElement(obj)
|
||
obj && (obj.nodeName || (obj.on && obj.find))) {
|
||
throw $parseMinErr('isecdom',
|
||
'Referencing DOM nodes in Angular expressions is disallowed! Expression: {0}', fullExpression);
|
||
} else {
|
||
return obj;
|
||
}
|
||
}
|
||
|
||
var OPERATORS = {
|
||
'null':function(){return null;},
|
||
'true':function(){return true;},
|
||
'false':function(){return false;},
|
||
undefined:noop,
|
||
'+':function(self, locals, a,b){
|
||
a=a(self, locals); b=b(self, locals);
|
||
if (isDefined(a)) {
|
||
if (isDefined(b)) {
|
||
return a + b;
|
||
}
|
||
return a;
|
||
}
|
||
return isDefined(b)?b:undefined;},
|
||
'-':function(self, locals, a,b){a=a(self, locals); b=b(self, locals); return (isDefined(a)?a:0)-(isDefined(b)?b:0);},
|
||
'*':function(self, locals, a,b){return a(self, locals)*b(self, locals);},
|
||
'/':function(self, locals, a,b){return a(self, locals)/b(self, locals);},
|
||
'%':function(self, locals, a,b){return a(self, locals)%b(self, locals);},
|
||
'^':function(self, locals, a,b){return a(self, locals)^b(self, locals);},
|
||
'=':noop,
|
||
'===':function(self, locals, a, b){return a(self, locals)===b(self, locals);},
|
||
'!==':function(self, locals, a, b){return a(self, locals)!==b(self, locals);},
|
||
'==':function(self, locals, a,b){return a(self, locals)==b(self, locals);},
|
||
'!=':function(self, locals, a,b){return a(self, locals)!=b(self, locals);},
|
||
'<':function(self, locals, a,b){return a(self, locals)<b(self, locals);},
|
||
'>':function(self, locals, a,b){return a(self, locals)>b(self, locals);},
|
||
'<=':function(self, locals, a,b){return a(self, locals)<=b(self, locals);},
|
||
'>=':function(self, locals, a,b){return a(self, locals)>=b(self, locals);},
|
||
'&&':function(self, locals, a,b){return a(self, locals)&&b(self, locals);},
|
||
'||':function(self, locals, a,b){return a(self, locals)||b(self, locals);},
|
||
'&':function(self, locals, a,b){return a(self, locals)&b(self, locals);},
|
||
// '|':function(self, locals, a,b){return a|b;},
|
||
'|':function(self, locals, a,b){return b(self, locals)(self, locals, a(self, locals));},
|
||
'!':function(self, locals, a){return !a(self, locals);}
|
||
};
|
||
var ESCAPE = {"n":"\n", "f":"\f", "r":"\r", "t":"\t", "v":"\v", "'":"'", '"':'"'};
|
||
|
||
function lex(text, csp){
|
||
var tokens = [],
|
||
token,
|
||
index = 0,
|
||
json = [],
|
||
ch,
|
||
lastCh = ':'; // can start regexp
|
||
|
||
while (index < text.length) {
|
||
ch = text.charAt(index);
|
||
if (is('"\'')) {
|
||
readString(ch);
|
||
} else if (isNumber(ch) || is('.') && isNumber(peek())) {
|
||
readNumber();
|
||
} else if (isIdent(ch)) {
|
||
readIdent();
|
||
// identifiers can only be if the preceding char was a { or ,
|
||
if (was('{,') && json[0]=='{' &&
|
||
(token=tokens[tokens.length-1])) {
|
||
token.json = token.text.indexOf('.') == -1;
|
||
}
|
||
} else if (is('(){}[].,;:?')) {
|
||
tokens.push({
|
||
index:index,
|
||
text:ch,
|
||
json:(was(':[,') && is('{[')) || is('}]:,')
|
||
});
|
||
if (is('{[')) json.unshift(ch);
|
||
if (is('}]')) json.shift();
|
||
index++;
|
||
} else if (isWhitespace(ch)) {
|
||
index++;
|
||
continue;
|
||
} else {
|
||
var ch2 = ch + peek(),
|
||
ch3 = ch2 + peek(2),
|
||
fn = OPERATORS[ch],
|
||
fn2 = OPERATORS[ch2],
|
||
fn3 = OPERATORS[ch3];
|
||
if (fn3) {
|
||
tokens.push({index:index, text:ch3, fn:fn3});
|
||
index += 3;
|
||
} else if (fn2) {
|
||
tokens.push({index:index, text:ch2, fn:fn2});
|
||
index += 2;
|
||
} else if (fn) {
|
||
tokens.push({index:index, text:ch, fn:fn, json: was('[,:') && is('+-')});
|
||
index += 1;
|
||
} else {
|
||
throwError("Unexpected next character ", index, index+1);
|
||
}
|
||
}
|
||
lastCh = ch;
|
||
}
|
||
return tokens;
|
||
|
||
function is(chars) {
|
||
return chars.indexOf(ch) != -1;
|
||
}
|
||
|
||
function was(chars) {
|
||
return chars.indexOf(lastCh) != -1;
|
||
}
|
||
|
||
function peek(i) {
|
||
var num = i || 1;
|
||
return index + num < text.length ? text.charAt(index + num) : false;
|
||
}
|
||
function isNumber(ch) {
|
||
return '0' <= ch && ch <= '9';
|
||
}
|
||
function isWhitespace(ch) {
|
||
return ch == ' ' || ch == '\r' || ch == '\t' ||
|
||
ch == '\n' || ch == '\v' || ch == '\u00A0'; // IE treats non-breaking space as \u00A0
|
||
}
|
||
function isIdent(ch) {
|
||
return 'a' <= ch && ch <= 'z' ||
|
||
'A' <= ch && ch <= 'Z' ||
|
||
'_' == ch || ch == '$';
|
||
}
|
||
function isExpOperator(ch) {
|
||
return ch == '-' || ch == '+' || isNumber(ch);
|
||
}
|
||
|
||
function throwError(error, start, end) {
|
||
end = end || index;
|
||
var colStr = (isDefined(start) ?
|
||
"s " + start + "-" + index + " [" + text.substring(start, end) + "]"
|
||
: " " + end);
|
||
throw $parseMinErr('lexerr', "Lexer Error: {0} at column{1} in expression [{2}].",
|
||
error, colStr, text);
|
||
}
|
||
|
||
function readNumber() {
|
||
var number = "";
|
||
var start = index;
|
||
while (index < text.length) {
|
||
var ch = lowercase(text.charAt(index));
|
||
if (ch == '.' || isNumber(ch)) {
|
||
number += ch;
|
||
} else {
|
||
var peekCh = peek();
|
||
if (ch == 'e' && isExpOperator(peekCh)) {
|
||
number += ch;
|
||
} else if (isExpOperator(ch) &&
|
||
peekCh && isNumber(peekCh) &&
|
||
number.charAt(number.length - 1) == 'e') {
|
||
number += ch;
|
||
} else if (isExpOperator(ch) &&
|
||
(!peekCh || !isNumber(peekCh)) &&
|
||
number.charAt(number.length - 1) == 'e') {
|
||
throwError('Invalid exponent');
|
||
} else {
|
||
break;
|
||
}
|
||
}
|
||
index++;
|
||
}
|
||
number = 1 * number;
|
||
tokens.push({index:start, text:number, json:true,
|
||
fn:function() {return number;}});
|
||
}
|
||
function readIdent() {
|
||
var ident = "",
|
||
start = index,
|
||
lastDot, peekIndex, methodName, ch;
|
||
|
||
while (index < text.length) {
|
||
ch = text.charAt(index);
|
||
if (ch == '.' || isIdent(ch) || isNumber(ch)) {
|
||
if (ch == '.') lastDot = index;
|
||
ident += ch;
|
||
} else {
|
||
break;
|
||
}
|
||
index++;
|
||
}
|
||
|
||
//check if this is not a method invocation and if it is back out to last dot
|
||
if (lastDot) {
|
||
peekIndex = index;
|
||
while(peekIndex < text.length) {
|
||
ch = text.charAt(peekIndex);
|
||
if (ch == '(') {
|
||
methodName = ident.substr(lastDot - start + 1);
|
||
ident = ident.substr(0, lastDot - start);
|
||
index = peekIndex;
|
||
break;
|
||
}
|
||
if(isWhitespace(ch)) {
|
||
peekIndex++;
|
||
} else {
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
|
||
|
||
var token = {
|
||
index:start,
|
||
text:ident
|
||
};
|
||
|
||
if (OPERATORS.hasOwnProperty(ident)) {
|
||
token.fn = token.json = OPERATORS[ident];
|
||
} else {
|
||
var getter = getterFn(ident, csp, text);
|
||
token.fn = extend(function(self, locals) {
|
||
return (getter(self, locals));
|
||
}, {
|
||
assign: function(self, value) {
|
||
return setter(self, ident, value, text);
|
||
}
|
||
});
|
||
}
|
||
|
||
tokens.push(token);
|
||
|
||
if (methodName) {
|
||
tokens.push({
|
||
index:lastDot,
|
||
text: '.',
|
||
json: false
|
||
});
|
||
tokens.push({
|
||
index: lastDot + 1,
|
||
text: methodName,
|
||
json: false
|
||
});
|
||
}
|
||
}
|
||
|
||
function readString(quote) {
|
||
var start = index;
|
||
index++;
|
||
var string = "";
|
||
var rawString = quote;
|
||
var escape = false;
|
||
while (index < text.length) {
|
||
var ch = text.charAt(index);
|
||
rawString += ch;
|
||
if (escape) {
|
||
if (ch == 'u') {
|
||
var hex = text.substring(index + 1, index + 5);
|
||
if (!hex.match(/[\da-f]{4}/i))
|
||
throwError( "Invalid unicode escape [\\u" + hex + "]");
|
||
index += 4;
|
||
string += String.fromCharCode(parseInt(hex, 16));
|
||
} else {
|
||
var rep = ESCAPE[ch];
|
||
if (rep) {
|
||
string += rep;
|
||
} else {
|
||
string += ch;
|
||
}
|
||
}
|
||
escape = false;
|
||
} else if (ch == '\\') {
|
||
escape = true;
|
||
} else if (ch == quote) {
|
||
index++;
|
||
tokens.push({
|
||
index:start,
|
||
text:rawString,
|
||
string:string,
|
||
json:true,
|
||
fn:function() { return string; }
|
||
});
|
||
return;
|
||
} else {
|
||
string += ch;
|
||
}
|
||
index++;
|
||
}
|
||
throwError("Unterminated quote", start);
|
||
}
|
||
}
|
||
|
||
/////////////////////////////////////////
|
||
|
||
function parser(text, json, $filter, csp){
|
||
var ZERO = valueFn(0),
|
||
value,
|
||
tokens = lex(text, csp),
|
||
assignment = _assignment,
|
||
functionCall = _functionCall,
|
||
fieldAccess = _fieldAccess,
|
||
objectIndex = _objectIndex,
|
||
filterChain = _filterChain;
|
||
|
||
if(json){
|
||
// The extra level of aliasing is here, just in case the lexer misses something, so that
|
||
// we prevent any accidental execution in JSON.
|
||
assignment = logicalOR;
|
||
functionCall =
|
||
fieldAccess =
|
||
objectIndex =
|
||
filterChain =
|
||
function() { throwError("is not valid json", {text:text, index:0}); };
|
||
value = primary();
|
||
} else {
|
||
value = statements();
|
||
}
|
||
if (tokens.length !== 0) {
|
||
throwError("is an unexpected token", tokens[0]);
|
||
}
|
||
value.literal = !!value.literal;
|
||
value.constant = !!value.constant;
|
||
return value;
|
||
|
||
///////////////////////////////////
|
||
function throwError(msg, token) {
|
||
throw $parseMinErr('syntax',
|
||
"Syntax Error: Token '{0}' {1} at column {2} of the expression [{3}] starting at [{4}].",
|
||
token.text, msg, (token.index + 1), text, text.substring(token.index));
|
||
}
|
||
|
||
function peekToken() {
|
||
if (tokens.length === 0)
|
||
throw $parseMinErr('ueoe', "Unexpected end of expression: {0}", text);
|
||
return tokens[0];
|
||
}
|
||
|
||
function peek(e1, e2, e3, e4) {
|
||
if (tokens.length > 0) {
|
||
var token = tokens[0];
|
||
var t = token.text;
|
||
if (t==e1 || t==e2 || t==e3 || t==e4 ||
|
||
(!e1 && !e2 && !e3 && !e4)) {
|
||
return token;
|
||
}
|
||
}
|
||
return false;
|
||
}
|
||
|
||
function expect(e1, e2, e3, e4){
|
||
var token = peek(e1, e2, e3, e4);
|
||
if (token) {
|
||
if (json && !token.json) {
|
||
throwError("is not valid json", token);
|
||
}
|
||
tokens.shift();
|
||
return token;
|
||
}
|
||
return false;
|
||
}
|
||
|
||
function consume(e1){
|
||
if (!expect(e1)) {
|
||
throwError("is unexpected, expecting [" + e1 + "]", peek());
|
||
}
|
||
}
|
||
|
||
function unaryFn(fn, right) {
|
||
return extend(function(self, locals) {
|
||
return fn(self, locals, right);
|
||
}, {
|
||
constant:right.constant
|
||
});
|
||
}
|
||
|
||
function ternaryFn(left, middle, right){
|
||
return extend(function(self, locals){
|
||
return left(self, locals) ? middle(self, locals) : right(self, locals);
|
||
}, {
|
||
constant: left.constant && middle.constant && right.constant
|
||
});
|
||
}
|
||
|
||
function binaryFn(left, fn, right) {
|
||
return extend(function(self, locals) {
|
||
return fn(self, locals, left, right);
|
||
}, {
|
||
constant:left.constant && right.constant
|
||
});
|
||
}
|
||
|
||
function statements() {
|
||
var statements = [];
|
||
while(true) {
|
||
if (tokens.length > 0 && !peek('}', ')', ';', ']'))
|
||
statements.push(filterChain());
|
||
if (!expect(';')) {
|
||
// optimize for the common case where there is only one statement.
|
||
// TODO(size): maybe we should not support multiple statements?
|
||
return statements.length == 1
|
||
? statements[0]
|
||
: function(self, locals){
|
||
var value;
|
||
for ( var i = 0; i < statements.length; i++) {
|
||
var statement = statements[i];
|
||
if (statement)
|
||
value = statement(self, locals);
|
||
}
|
||
return value;
|
||
};
|
||
}
|
||
}
|
||
}
|
||
|
||
function _filterChain() {
|
||
var left = expression();
|
||
var token;
|
||
while(true) {
|
||
if ((token = expect('|'))) {
|
||
left = binaryFn(left, token.fn, filter());
|
||
} else {
|
||
return left;
|
||
}
|
||
}
|
||
}
|
||
|
||
function filter() {
|
||
var token = expect();
|
||
var fn = $filter(token.text);
|
||
var argsFn = [];
|
||
while(true) {
|
||
if ((token = expect(':'))) {
|
||
argsFn.push(expression());
|
||
} else {
|
||
var fnInvoke = function(self, locals, input){
|
||
var args = [input];
|
||
for ( var i = 0; i < argsFn.length; i++) {
|
||
args.push(argsFn[i](self, locals));
|
||
}
|
||
return fn.apply(self, args);
|
||
};
|
||
return function() {
|
||
return fnInvoke;
|
||
};
|
||
}
|
||
}
|
||
}
|
||
|
||
function expression() {
|
||
return assignment();
|
||
}
|
||
|
||
function _assignment() {
|
||
var left = ternary();
|
||
var right;
|
||
var token;
|
||
if ((token = expect('='))) {
|
||
if (!left.assign) {
|
||
throwError("implies assignment but [" +
|
||
text.substring(0, token.index) + "] can not be assigned to", token);
|
||
}
|
||
right = ternary();
|
||
return function(scope, locals){
|
||
return left.assign(scope, right(scope, locals), locals);
|
||
};
|
||
} else {
|
||
return left;
|
||
}
|
||
}
|
||
|
||
function ternary() {
|
||
var left = logicalOR();
|
||
var middle;
|
||
var token;
|
||
if((token = expect('?'))){
|
||
middle = ternary();
|
||
if((token = expect(':'))){
|
||
return ternaryFn(left, middle, ternary());
|
||
}
|
||
else {
|
||
throwError('expected :', token);
|
||
}
|
||
}
|
||
else {
|
||
return left;
|
||
}
|
||
}
|
||
|
||
function logicalOR() {
|
||
var left = logicalAND();
|
||
var token;
|
||
while(true) {
|
||
if ((token = expect('||'))) {
|
||
left = binaryFn(left, token.fn, logicalAND());
|
||
} else {
|
||
return left;
|
||
}
|
||
}
|
||
}
|
||
|
||
function logicalAND() {
|
||
var left = equality();
|
||
var token;
|
||
if ((token = expect('&&'))) {
|
||
left = binaryFn(left, token.fn, logicalAND());
|
||
}
|
||
return left;
|
||
}
|
||
|
||
function equality() {
|
||
var left = relational();
|
||
var token;
|
||
if ((token = expect('==','!=','===','!=='))) {
|
||
left = binaryFn(left, token.fn, equality());
|
||
}
|
||
return left;
|
||
}
|
||
|
||
function relational() {
|
||
var left = additive();
|
||
var token;
|
||
if ((token = expect('<', '>', '<=', '>='))) {
|
||
left = binaryFn(left, token.fn, relational());
|
||
}
|
||
return left;
|
||
}
|
||
|
||
function additive() {
|
||
var left = multiplicative();
|
||
var token;
|
||
while ((token = expect('+','-'))) {
|
||
left = binaryFn(left, token.fn, multiplicative());
|
||
}
|
||
return left;
|
||
}
|
||
|
||
function multiplicative() {
|
||
var left = unary();
|
||
var token;
|
||
while ((token = expect('*','/','%'))) {
|
||
left = binaryFn(left, token.fn, unary());
|
||
}
|
||
return left;
|
||
}
|
||
|
||
function unary() {
|
||
var token;
|
||
if (expect('+')) {
|
||
return primary();
|
||
} else if ((token = expect('-'))) {
|
||
return binaryFn(ZERO, token.fn, unary());
|
||
} else if ((token = expect('!'))) {
|
||
return unaryFn(token.fn, unary());
|
||
} else {
|
||
return primary();
|
||
}
|
||
}
|
||
|
||
|
||
function primary() {
|
||
var primary;
|
||
if (expect('(')) {
|
||
primary = filterChain();
|
||
consume(')');
|
||
} else if (expect('[')) {
|
||
primary = arrayDeclaration();
|
||
} else if (expect('{')) {
|
||
primary = object();
|
||
} else {
|
||
var token = expect();
|
||
primary = token.fn;
|
||
if (!primary) {
|
||
throwError("not a primary expression", token);
|
||
}
|
||
if (token.json) {
|
||
primary.constant = primary.literal = true;
|
||
}
|
||
}
|
||
|
||
var next, context;
|
||
while ((next = expect('(', '[', '.'))) {
|
||
if (next.text === '(') {
|
||
primary = functionCall(primary, context);
|
||
context = null;
|
||
} else if (next.text === '[') {
|
||
context = primary;
|
||
primary = objectIndex(primary);
|
||
} else if (next.text === '.') {
|
||
context = primary;
|
||
primary = fieldAccess(primary);
|
||
} else {
|
||
throwError("IMPOSSIBLE");
|
||
}
|
||
}
|
||
return primary;
|
||
}
|
||
|
||
function _fieldAccess(object) {
|
||
var field = expect().text;
|
||
var getter = getterFn(field, csp, text);
|
||
return extend(
|
||
function(scope, locals, self) {
|
||
return getter(self || object(scope, locals), locals);
|
||
},
|
||
{
|
||
assign:function(scope, value, locals) {
|
||
return setter(object(scope, locals), field, value, text);
|
||
}
|
||
}
|
||
);
|
||
}
|
||
|
||
function _objectIndex(obj) {
|
||
var indexFn = expression();
|
||
consume(']');
|
||
return extend(
|
||
function(self, locals){
|
||
var o = obj(self, locals),
|
||
i = indexFn(self, locals),
|
||
v, p;
|
||
|
||
if (!o) return undefined;
|
||
v = ensureSafeObject(o[i], text);
|
||
if (v && v.then) {
|
||
p = v;
|
||
if (!('$$v' in v)) {
|
||
p.$$v = undefined;
|
||
p.then(function(val) { p.$$v = val; });
|
||
}
|
||
v = v.$$v;
|
||
}
|
||
return v;
|
||
}, {
|
||
assign:function(self, value, locals){
|
||
var key = indexFn(self, locals);
|
||
// prevent overwriting of Function.constructor which would break ensureSafeObject check
|
||
return ensureSafeObject(obj(self, locals), text)[key] = value;
|
||
}
|
||
});
|
||
}
|
||
|
||
function _functionCall(fn, contextGetter) {
|
||
var argsFn = [];
|
||
if (peekToken().text != ')') {
|
||
do {
|
||
argsFn.push(expression());
|
||
} while (expect(','));
|
||
}
|
||
consume(')');
|
||
return function(scope, locals){
|
||
var args = [],
|
||
context = contextGetter ? contextGetter(scope, locals) : scope;
|
||
|
||
for ( var i = 0; i < argsFn.length; i++) {
|
||
args.push(argsFn[i](scope, locals));
|
||
}
|
||
var fnPtr = fn(scope, locals, context) || noop;
|
||
|
||
ensureSafeObject(fnPtr, text);
|
||
|
||
// IE stupidity!
|
||
var v = fnPtr.apply
|
||
? fnPtr.apply(context, args)
|
||
: fnPtr(args[0], args[1], args[2], args[3], args[4]);
|
||
|
||
// Check for promise
|
||
if (v && v.then) {
|
||
var p = v;
|
||
if (!('$$v' in v)) {
|
||
p.$$v = undefined;
|
||
p.then(function(val) { p.$$v = val; });
|
||
}
|
||
v = v.$$v;
|
||
}
|
||
|
||
return ensureSafeObject(v, text);
|
||
};
|
||
}
|
||
|
||
// This is used with json array declaration
|
||
function arrayDeclaration () {
|
||
var elementFns = [];
|
||
var allConstant = true;
|
||
if (peekToken().text != ']') {
|
||
do {
|
||
var elementFn = expression();
|
||
elementFns.push(elementFn);
|
||
if (!elementFn.constant) {
|
||
allConstant = false;
|
||
}
|
||
} while (expect(','));
|
||
}
|
||
consume(']');
|
||
return extend(function(self, locals){
|
||
var array = [];
|
||
for ( var i = 0; i < elementFns.length; i++) {
|
||
array.push(elementFns[i](self, locals));
|
||
}
|
||
return array;
|
||
}, {
|
||
literal:true,
|
||
constant:allConstant
|
||
});
|
||
}
|
||
|
||
function object () {
|
||
var keyValues = [];
|
||
var allConstant = true;
|
||
if (peekToken().text != '}') {
|
||
do {
|
||
var token = expect(),
|
||
key = token.string || token.text;
|
||
consume(":");
|
||
var value = expression();
|
||
keyValues.push({key:key, value:value});
|
||
if (!value.constant) {
|
||
allConstant = false;
|
||
}
|
||
} while (expect(','));
|
||
}
|
||
consume('}');
|
||
return extend(function(self, locals){
|
||
var object = {};
|
||
for ( var i = 0; i < keyValues.length; i++) {
|
||
var keyValue = keyValues[i];
|
||
object[keyValue.key] = keyValue.value(self, locals);
|
||
}
|
||
return object;
|
||
}, {
|
||
literal:true,
|
||
constant:allConstant
|
||
});
|
||
}
|
||
}
|
||
|
||
//////////////////////////////////////////////////
|
||
// Parser helper functions
|
||
//////////////////////////////////////////////////
|
||
|
||
function setter(obj, path, setValue, fullExp) {
|
||
var element = path.split('.'), key;
|
||
for (var i = 0; element.length > 1; i++) {
|
||
key = ensureSafeMemberName(element.shift(), fullExp);
|
||
var propertyObj = obj[key];
|
||
if (!propertyObj) {
|
||
propertyObj = {};
|
||
obj[key] = propertyObj;
|
||
}
|
||
obj = propertyObj;
|
||
if (obj.then) {
|
||
if (!("$$v" in obj)) {
|
||
(function(promise) {
|
||
promise.then(function(val) { promise.$$v = val; }); }
|
||
)(obj);
|
||
}
|
||
if (obj.$$v === undefined) {
|
||
obj.$$v = {};
|
||
}
|
||
obj = obj.$$v;
|
||
}
|
||
}
|
||
key = ensureSafeMemberName(element.shift(), fullExp);
|
||
obj[key] = setValue;
|
||
return setValue;
|
||
}
|
||
|
||
var getterFnCache = {};
|
||
|
||
/**
|
||
* Implementation of the "Black Hole" variant from:
|
||
* - http://jsperf.com/angularjs-parse-getter/4
|
||
* - http://jsperf.com/path-evaluation-simplified/7
|
||
*/
|
||
function cspSafeGetterFn(key0, key1, key2, key3, key4, fullExp) {
|
||
ensureSafeMemberName(key0, fullExp);
|
||
ensureSafeMemberName(key1, fullExp);
|
||
ensureSafeMemberName(key2, fullExp);
|
||
ensureSafeMemberName(key3, fullExp);
|
||
ensureSafeMemberName(key4, fullExp);
|
||
return function(scope, locals) {
|
||
var pathVal = (locals && locals.hasOwnProperty(key0)) ? locals : scope,
|
||
promise;
|
||
|
||
if (pathVal === null || pathVal === undefined) return pathVal;
|
||
|
||
pathVal = pathVal[key0];
|
||
if (pathVal && pathVal.then) {
|
||
if (!("$$v" in pathVal)) {
|
||
promise = pathVal;
|
||
promise.$$v = undefined;
|
||
promise.then(function(val) { promise.$$v = val; });
|
||
}
|
||
pathVal = pathVal.$$v;
|
||
}
|
||
if (!key1 || pathVal === null || pathVal === undefined) return pathVal;
|
||
|
||
pathVal = pathVal[key1];
|
||
if (pathVal && pathVal.then) {
|
||
if (!("$$v" in pathVal)) {
|
||
promise = pathVal;
|
||
promise.$$v = undefined;
|
||
promise.then(function(val) { promise.$$v = val; });
|
||
}
|
||
pathVal = pathVal.$$v;
|
||
}
|
||
if (!key2 || pathVal === null || pathVal === undefined) return pathVal;
|
||
|
||
pathVal = pathVal[key2];
|
||
if (pathVal && pathVal.then) {
|
||
if (!("$$v" in pathVal)) {
|
||
promise = pathVal;
|
||
promise.$$v = undefined;
|
||
promise.then(function(val) { promise.$$v = val; });
|
||
}
|
||
pathVal = pathVal.$$v;
|
||
}
|
||
if (!key3 || pathVal === null || pathVal === undefined) return pathVal;
|
||
|
||
pathVal = pathVal[key3];
|
||
if (pathVal && pathVal.then) {
|
||
if (!("$$v" in pathVal)) {
|
||
promise = pathVal;
|
||
promise.$$v = undefined;
|
||
promise.then(function(val) { promise.$$v = val; });
|
||
}
|
||
pathVal = pathVal.$$v;
|
||
}
|
||
if (!key4 || pathVal === null || pathVal === undefined) return pathVal;
|
||
|
||
pathVal = pathVal[key4];
|
||
if (pathVal && pathVal.then) {
|
||
if (!("$$v" in pathVal)) {
|
||
promise = pathVal;
|
||
promise.$$v = undefined;
|
||
promise.then(function(val) { promise.$$v = val; });
|
||
}
|
||
pathVal = pathVal.$$v;
|
||
}
|
||
return pathVal;
|
||
};
|
||
}
|
||
|
||
function getterFn(path, csp, fullExp) {
|
||
if (getterFnCache.hasOwnProperty(path)) {
|
||
return getterFnCache[path];
|
||
}
|
||
|
||
var pathKeys = path.split('.'),
|
||
pathKeysLength = pathKeys.length,
|
||
fn;
|
||
|
||
if (csp) {
|
||
fn = (pathKeysLength < 6)
|
||
? cspSafeGetterFn(pathKeys[0], pathKeys[1], pathKeys[2], pathKeys[3], pathKeys[4], fullExp)
|
||
: function(scope, locals) {
|
||
var i = 0, val;
|
||
do {
|
||
val = cspSafeGetterFn(
|
||
pathKeys[i++], pathKeys[i++], pathKeys[i++], pathKeys[i++], pathKeys[i++], fullExp
|
||
)(scope, locals);
|
||
|
||
locals = undefined; // clear after first iteration
|
||
scope = val;
|
||
} while (i < pathKeysLength);
|
||
return val;
|
||
}
|
||
} else {
|
||
var code = 'var l, fn, p;\n';
|
||
forEach(pathKeys, function(key, index) {
|
||
ensureSafeMemberName(key, fullExp);
|
||
code += 'if(s === null || s === undefined) return s;\n' +
|
||
'l=s;\n' +
|
||
's='+ (index
|
||
// we simply dereference 's' on any .dot notation
|
||
? 's'
|
||
// but if we are first then we check locals first, and if so read it first
|
||
: '((k&&k.hasOwnProperty("' + key + '"))?k:s)') + '["' + key + '"]' + ';\n' +
|
||
'if (s && s.then) {\n' +
|
||
' if (!("$$v" in s)) {\n' +
|
||
' p=s;\n' +
|
||
' p.$$v = undefined;\n' +
|
||
' p.then(function(v) {p.$$v=v;});\n' +
|
||
'}\n' +
|
||
' s=s.$$v\n' +
|
||
'}\n';
|
||
});
|
||
code += 'return s;';
|
||
fn = Function('s', 'k', code); // s=scope, k=locals
|
||
fn.toString = function() { return code; };
|
||
}
|
||
|
||
return getterFnCache[path] = fn;
|
||
}
|
||
|
||
///////////////////////////////////
|
||
|
||
/**
|
||
* @ngdoc function
|
||
* @name ng.$parse
|
||
* @function
|
||
*
|
||
* @description
|
||
*
|
||
* Converts Angular {@link guide/expression expression} into a function.
|
||
*
|
||
* <pre>
|
||
* var getter = $parse('user.name');
|
||
* var setter = getter.assign;
|
||
* var context = {user:{name:'angular'}};
|
||
* var locals = {user:{name:'local'}};
|
||
*
|
||
* expect(getter(context)).toEqual('angular');
|
||
* setter(context, 'newValue');
|
||
* expect(context.user.name).toEqual('newValue');
|
||
* expect(getter(context, locals)).toEqual('local');
|
||
* </pre>
|
||
*
|
||
*
|
||
* @param {string} expression String expression to compile.
|
||
* @returns {function(context, locals)} a function which represents the compiled expression:
|
||
*
|
||
* * `context` – `{object}` – an object against which any expressions embedded in the strings
|
||
* are evaluated against (typically a scope object).
|
||
* * `locals` – `{object=}` – local variables context object, useful for overriding values in
|
||
* `context`.
|
||
*
|
||
* The returned function also has the following properties:
|
||
* * `literal` – `{boolean}` – whether the expression's top-level node is a JavaScript
|
||
* literal.
|
||
* * `constant` – `{boolean}` – whether the expression is made entirely of JavaScript
|
||
* constant literals.
|
||
* * `assign` – `{?function(context, value)}` – if the expression is assignable, this will be
|
||
* set to a function to change its value on the given context.
|
||
*
|
||
*/
|
||
function $ParseProvider() {
|
||
var cache = {};
|
||
this.$get = ['$filter', '$sniffer', function($filter, $sniffer) {
|
||
return function(exp) {
|
||
switch(typeof exp) {
|
||
case 'string':
|
||
return cache.hasOwnProperty(exp)
|
||
? cache[exp]
|
||
: cache[exp] = parser(exp, false, $filter, $sniffer.csp);
|
||
case 'function':
|
||
return exp;
|
||
default:
|
||
return noop;
|
||
}
|
||
};
|
||
}];
|
||
}
|