ashatora/openlayers
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Rename ol.expression to ol.expr

Browse Source
This commit is contained in:
Tim Schaub
2013-06-21 17:29:16 -06:00
parent 9928730bd3
commit 2577d3f7d6
28 changed files with 1550 additions and 1548 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
examples/style-rules.js
View File

@@ -2,7 +2,7 @@ goog.require('ol.Map');
goog.require('ol.RendererHint'); goog.require('ol.RendererHint');
goog.require('ol.View2D'); goog.require('ol.View2D');
goog.require('ol.control.defaults'); goog.require('ol.control.defaults');
goog.require('ol.expression'); goog.require('ol.expr');
goog.require('ol.layer.Vector'); goog.require('ol.layer.Vector');
goog.require('ol.parser.GeoJSON'); goog.require('ol.parser.GeoJSON');
goog.require('ol.proj'); goog.require('ol.proj');
@@ -19,7 +19,7 @@ var style = new ol.style.Style({rules: [
filter: 'where == "outer"', filter: 'where == "outer"',
symbolizers: [ symbolizers: [
new ol.style.Line({ new ol.style.Line({
strokeColor: ol.expression.parse('color'), strokeColor: ol.expr.parse('color'),
strokeWidth: 4, strokeWidth: 4,
opacity: 1 opacity: 1
}) })
@@ -34,7 +34,7 @@ var style = new ol.style.Style({rules: [
opacity: 1 opacity: 1
}), }),
new ol.style.Line({ new ol.style.Line({
strokeColor: ol.expression.parse('color'), strokeColor: ol.expr.parse('color'),
strokeWidth: 2, strokeWidth: 2,
opacity: 1 opacity: 1
}) })
@@ -49,7 +49,7 @@ var style = new ol.style.Style({rules: [
}), }),
new ol.style.Text({ new ol.style.Text({
color: '#bada55', color: '#bada55',
text: ol.expression.parse('label'), text: ol.expr.parse('label'),
fontFamily: 'Calibri,sans-serif', fontFamily: 'Calibri,sans-serif',
fontSize: 14 fontSize: 14
}) })

6
examples/vector-layer.js
View File

@@ -1,7 +1,7 @@
goog.require('ol.Map'); goog.require('ol.Map');
goog.require('ol.RendererHint'); goog.require('ol.RendererHint');
goog.require('ol.View2D'); goog.require('ol.View2D');
goog.require('ol.expression'); goog.require('ol.expr');
goog.require('ol.layer.TileLayer'); goog.require('ol.layer.TileLayer');
goog.require('ol.layer.Vector'); goog.require('ol.layer.Vector');
goog.require('ol.parser.GeoJSON'); goog.require('ol.parser.GeoJSON');
@@ -19,7 +19,7 @@ var raster = new ol.layer.TileLayer({
}); });
// TODO: discuss scale dependent rules // TODO: discuss scale dependent rules
ol.expression.register('resolution', function() { ol.expr.register('resolution', function() {
return map.getView().getView2D().getResolution(); return map.getView().getView2D().getResolution();
}); });
@@ -40,7 +40,7 @@ var vector = new ol.layer.Vector({
symbolizers: [ symbolizers: [
new ol.style.Text({ new ol.style.Text({
color: '#bada55', color: '#bada55',
text: ol.expression.parse('name'), text: ol.expr.parse('name'),
fontFamily: 'Calibri,sans-serif', fontFamily: 'Calibri,sans-serif',
fontSize: 12 fontSize: 12
}) })

46
src/objectliterals.jsdoc
View File

@@ -519,54 +519,54 @@
/** /**
* @typedef {Object} ol.style.IconOptions * @typedef {Object} ol.style.IconOptions
* @property {string|ol.expression.Expression} url Icon image url. * @property {string|ol.expr.Expression} url Icon image url.
* @property {number|ol.expression.Expression|undefined} width Width of the icon * @property {number|ol.expr.Expression|undefined} width Width of the icon
* in pixels. Default is the width of the icon image. * in pixels. Default is the width of the icon image.
* @property {number|ol.expression.Expression|undefined} height Height of the * @property {number|ol.expr.Expression|undefined} height Height of the
* icon in pixels. Default is the height of the icon image. * icon in pixels. Default is the height of the icon image.
* @property {number|ol.expression.Expression|undefined} opacity Icon opacity * @property {number|ol.expr.Expression|undefined} opacity Icon opacity
* (0-1). * (0-1).
* @property {number|ol.expression.Expression|undefined} rotation Rotation in * @property {number|ol.expr.Expression|undefined} rotation Rotation in
* degrees (0-360). * degrees (0-360).
*/ */
/** /**
* @typedef {Object} ol.style.LineOptions * @typedef {Object} ol.style.LineOptions
* @property {string|ol.expression.Expression|undefined} strokeColor Stroke * @property {string|ol.expr.Expression|undefined} strokeColor Stroke
* color as hex color code. * color as hex color code.
* @property {number|ol.expression.Expression|undefined} strokeWidth Stroke * @property {number|ol.expr.Expression|undefined} strokeWidth Stroke
* width in pixels. * width in pixels.
* @property {number|ol.expression.Expression|undefined} opacity Opacity (0-1). * @property {number|ol.expr.Expression|undefined} opacity Opacity (0-1).
*/ */
/** /**
* @typedef {Object} ol.style.PolygonOptions * @typedef {Object} ol.style.PolygonOptions
* @property {string|ol.expression.Expression|undefined} fillColor Fill color as * @property {string|ol.expr.Expression|undefined} fillColor Fill color as
* hex color code. * hex color code.
* @property {string|ol.expression.Expression|undefined} strokeColor Stroke * @property {string|ol.expr.Expression|undefined} strokeColor Stroke
* color as hex color code. * color as hex color code.
* @property {number|ol.expression.Expression|undefined} strokeWidth Stroke * @property {number|ol.expr.Expression|undefined} strokeWidth Stroke
* width in pixels. * width in pixels.
* @property {number|ol.expression.Expression|undefined} opacity Opacity (0-1). * @property {number|ol.expr.Expression|undefined} opacity Opacity (0-1).
*/ */
/** /**
* @typedef {Object} ol.style.RuleOptions * @typedef {Object} ol.style.RuleOptions
* @property {ol.expression.Expression|string|undefined} filter Filter. * @property {ol.expr.Expression|string|undefined} filter Filter.
* @property {Array.<ol.style.Symbolizer>|undefined} symbolizers Symbolizers. * @property {Array.<ol.style.Symbolizer>|undefined} symbolizers Symbolizers.
*/ */
/** /**
* @typedef {Object} ol.style.ShapeOptions * @typedef {Object} ol.style.ShapeOptions
* @property {ol.style.ShapeType|undefined} type Type. * @property {ol.style.ShapeType|undefined} type Type.
* @property {number|ol.expression.Expression|undefined} size Size in pixels. * @property {number|ol.expr.Expression|undefined} size Size in pixels.
* @property {string|ol.expression.Expression|undefined} fillColor Fill color as * @property {string|ol.expr.Expression|undefined} fillColor Fill color as
* hex color code. * hex color code.
* @property {string|ol.expression.Expression|undefined} strokeColor Stroke * @property {string|ol.expr.Expression|undefined} strokeColor Stroke
* color as hex color code. * color as hex color code.
* @property {number|ol.expression.Expression|undefined} strokeWidth Stroke * @property {number|ol.expr.Expression|undefined} strokeWidth Stroke
* width in pixels. * width in pixels.
* @property {number|ol.expression.Expression|undefined} opacity Opacity (0-1). * @property {number|ol.expr.Expression|undefined} opacity Opacity (0-1).
*/ */
/** /**
@@ -576,11 +576,11 @@
/** /**
* @typedef {Object} ol.style.TextOptions * @typedef {Object} ol.style.TextOptions
* @property {string|ol.expression.Expression|undefined} color Color. * @property {string|ol.expr.Expression|undefined} color Color.
* @property {string|ol.expression.Expression|undefined} fontFamily Font family. * @property {string|ol.expr.Expression|undefined} fontFamily Font family.
* @property {number|ol.expression.Expression|undefined} fontSize Font size in pixels. * @property {number|ol.expr.Expression|undefined} fontSize Font size in pixels.
* @property {string|ol.expression.Expression} text Text for the label. * @property {string|ol.expr.Expression} text Text for the label.
* @property {number|ol.expression.Expression|undefined} opacity Opacity (0-1). * @property {number|ol.expr.Expression|undefined} opacity Opacity (0-1).
*/ */
/** /**

3
src/ol/expr.jsdoc Normal file
View File

@@ -0,0 +1,3 @@
/**
* @namespace ol.expr
*/

2
src/ol/expr/expression.exports Normal file
View File

@@ -0,0 +1,2 @@
@exportSymbol ol.expr.parse
@exportSymbol ol.expr.register

44
src/ol/expression/expression.js → src/ol/expr/expression.js
View File

@@ -1,29 +1,29 @@
goog.provide('ol.expression'); goog.provide('ol.expr');
goog.require('ol.Extent'); goog.require('ol.Extent');
goog.require('ol.Feature'); goog.require('ol.Feature');
goog.require('ol.expression.Call'); goog.require('ol.expr.Call');
goog.require('ol.expression.Expression'); goog.require('ol.expr.Expression');
goog.require('ol.expression.Identifier'); goog.require('ol.expr.Identifier');
goog.require('ol.expression.Parser'); goog.require('ol.expr.Parser');
goog.require('ol.extent'); goog.require('ol.extent');
goog.require('ol.geom.GeometryType'); goog.require('ol.geom.GeometryType');
/** /**
* Evaluate an expression with a feature. The feature attributes will be used * Evaluate an expression with a feature. The feature attributes will be used
* as the evaluation scope. The `ol.expression.lib` functions will be used as * as the evaluation scope. The `ol.expr.lib` functions will be used as
* function scope. The feature itself will be used as the `this` argument. * function scope. The feature itself will be used as the `this` argument.
* *
* @param {ol.expression.Expression} expr The expression. * @param {ol.expr.Expression} expr The expression.
* @param {ol.Feature=} opt_feature The feature. * @param {ol.Feature=} opt_feature The feature.
* @return {*} The result of the expression. * @return {*} The result of the expression.
*/ */
ol.expression.evaluateFeature = function(expr, opt_feature) { ol.expr.evaluateFeature = function(expr, opt_feature) {
var result; var result;
if (goog.isDef(opt_feature)) { if (goog.isDef(opt_feature)) {
result = expr.evaluate( result = expr.evaluate(
opt_feature.getAttributes(), ol.expression.lib, opt_feature); opt_feature.getAttributes(), ol.expr.lib, opt_feature);
} else { } else {
result = expr.evaluate(); result = expr.evaluate();
} }
@@ -34,11 +34,11 @@ ol.expression.evaluateFeature = function(expr, opt_feature) {
/** /**
* Parse an expression. * Parse an expression.
* @param {string} source The expression source (e.g. `'foo + 2'`). * @param {string} source The expression source (e.g. `'foo + 2'`).
* @return {ol.expression.Expression} An expression instance that can be * @return {ol.expr.Expression} An expression instance that can be
* evaluated within some scope to provide a value. * evaluated within some scope to provide a value.
*/ */
ol.expression.parse = function(source) { ol.expr.parse = function(source) {
var parser = new ol.expression.Parser(); var parser = new ol.expr.Parser();
return parser.parse(source); return parser.parse(source);
}; };
@@ -50,27 +50,27 @@ ol.expression.parse = function(source) {
* expression. This function will be called with a feature as the `this` * expression. This function will be called with a feature as the `this`
* argument when the expression is evaluated in the context of a features. * argument when the expression is evaluated in the context of a features.
*/ */
ol.expression.register = function(name, func) { ol.expr.register = function(name, func) {
ol.expression.lib[name] = func; ol.expr.lib[name] = func;
}; };
/** /**
* Determines whether an expression is a call expression that calls one of the * Determines whether an expression is a call expression that calls one of the
* `ol.expression.lib` functions. * `ol.expr.lib` functions.
* *
* @param {ol.expression.Expression} expr The candidate expression. * @param {ol.expr.Expression} expr The candidate expression.
* @return {string|undefined} If the candidate expression is a call to a lib * @return {string|undefined} If the candidate expression is a call to a lib
* function, the return will be the function name. If not, the return will be * function, the return will be the function name. If not, the return will be
* `undefined`. * `undefined`.
*/ */
ol.expression.isLibCall = function(expr) { ol.expr.isLibCall = function(expr) {
var name; var name;
if (expr instanceof ol.expression.Call) { if (expr instanceof ol.expr.Call) {
var callee = expr.getCallee(); var callee = expr.getCallee();
if (callee instanceof ol.expression.Identifier) { if (callee instanceof ol.expr.Identifier) {
name = callee.getName(); name = callee.getName();
if (!ol.expression.lib.hasOwnProperty(name)) { if (!ol.expr.lib.hasOwnProperty(name)) {
name = undefined; name = undefined;
} }
} }
@@ -81,11 +81,11 @@ ol.expression.isLibCall = function(expr) {
/** /**
* Library of well-known functions. These are available to expressions parsed * Library of well-known functions. These are available to expressions parsed
* with `ol.expression.parse`. * with `ol.expr.parse`.
* *
* @type {Object} * @type {Object}
*/ */
ol.expression.lib = { ol.expr.lib = {
/** /**
* Determine if a feature's extent intersects the provided extent. * Determine if a feature's extent intersects the provided extent.

258
src/ol/expression/expressions.js → src/ol/expr/expressions.js
View File

@@ -1,20 +1,20 @@
goog.provide('ol.expression.Call'); goog.provide('ol.expr.Call');
goog.provide('ol.expression.Comparison'); goog.provide('ol.expr.Comparison');
goog.provide('ol.expression.ComparisonOp'); goog.provide('ol.expr.ComparisonOp');
goog.provide('ol.expression.Expression'); goog.provide('ol.expr.Expression');
goog.provide('ol.expression.Identifier'); goog.provide('ol.expr.Identifier');
goog.provide('ol.expression.Literal'); goog.provide('ol.expr.Literal');
goog.provide('ol.expression.Logical'); goog.provide('ol.expr.Logical');
goog.provide('ol.expression.LogicalOp'); goog.provide('ol.expr.LogicalOp');
goog.provide('ol.expression.Math'); goog.provide('ol.expr.Math');
goog.provide('ol.expression.MathOp'); goog.provide('ol.expr.MathOp');
goog.provide('ol.expression.Member'); goog.provide('ol.expr.Member');
goog.provide('ol.expression.Not'); goog.provide('ol.expr.Not');
/** /**
* Base class for all expressions. Instances of ol.expression.Expression * Base class for all expressions. Instances of ol.expr.Expression
* correspond to a limited set of ECMAScript 5.1 expressions. * correspond to a limited set of ECMAScript 5.1 expressions.
* http://www.ecma-international.org/ecma-262/5.1/#sec-11 * http://www.ecma-international.org/ecma-262/5.1/#sec-11
* *
@@ -23,7 +23,7 @@ goog.provide('ol.expression.Not');
* *
* @constructor * @constructor
*/ */
ol.expression.Expression = function() {}; ol.expr.Expression = function() {};
/** /**
@@ -38,7 +38,7 @@ ol.expression.Expression = function() {};
* expressions. If not provided, `this` will resolve to a new object. * expressions. If not provided, `this` will resolve to a new object.
* @return {*} Result of the expression. * @return {*} Result of the expression.
*/ */
ol.expression.Expression.prototype.evaluate = goog.abstractMethod; ol.expr.Expression.prototype.evaluate = goog.abstractMethod;
@@ -46,33 +46,33 @@ ol.expression.Expression.prototype.evaluate = goog.abstractMethod;
* A call expression (e.g. `foo(bar)`). * A call expression (e.g. `foo(bar)`).
* *
* @constructor * @constructor
* @extends {ol.expression.Expression} * @extends {ol.expr.Expression}
* @param {ol.expression.Expression} callee An expression that resolves to a * @param {ol.expr.Expression} callee An expression that resolves to a
* function. * function.
* @param {Array.<ol.expression.Expression>} args Arguments. * @param {Array.<ol.expr.Expression>} args Arguments.
*/ */
ol.expression.Call = function(callee, args) { ol.expr.Call = function(callee, args) {
/** /**
* @type {ol.expression.Expression} * @type {ol.expr.Expression}
* @private * @private
*/ */
this.callee_ = callee; this.callee_ = callee;
/** /**
* @type {Array.<ol.expression.Expression>} * @type {Array.<ol.expr.Expression>}
* @private * @private
*/ */
this.args_ = args; this.args_ = args;
}; };
goog.inherits(ol.expression.Call, ol.expression.Expression); goog.inherits(ol.expr.Call, ol.expr.Expression);
/** /**
* @inheritDoc * @inheritDoc
*/ */
ol.expression.Call.prototype.evaluate = function(opt_scope, opt_fns, opt_this) { ol.expr.Call.prototype.evaluate = function(opt_scope, opt_fns, opt_this) {
var fnScope = goog.isDefAndNotNull(opt_fns) ? opt_fns : opt_scope; var fnScope = goog.isDefAndNotNull(opt_fns) ? opt_fns : opt_scope;
var fn = this.callee_.evaluate(fnScope); var fn = this.callee_.evaluate(fnScope);
if (!fn || !goog.isFunction(fn)) { if (!fn || !goog.isFunction(fn)) {
@@ -91,18 +91,18 @@ ol.expression.Call.prototype.evaluate = function(opt_scope, opt_fns, opt_this) {
/** /**
* Get the argument list. * Get the argument list.
* @return {Array.<ol.expression.Expression>} The argument. * @return {Array.<ol.expr.Expression>} The argument.
*/ */
ol.expression.Call.prototype.getArgs = function() { ol.expr.Call.prototype.getArgs = function() {
return this.args_; return this.args_;
}; };
/** /**
* Get the callee expression. * Get the callee expression.
* @return {ol.expression.Expression} The callee expression. * @return {ol.expr.Expression} The callee expression.
*/ */
ol.expression.Call.prototype.getCallee = function() { ol.expr.Call.prototype.getCallee = function() {
return this.callee_; return this.callee_;
}; };
@@ -110,7 +110,7 @@ ol.expression.Call.prototype.getCallee = function() {
/** /**
* @enum {string} * @enum {string}
*/ */
ol.expression.ComparisonOp = { ol.expr.ComparisonOp = {
EQ: '==', EQ: '==',
NEQ: '!=', NEQ: '!=',
STRICT_EQ: '===', STRICT_EQ: '===',
@@ -127,33 +127,33 @@ ol.expression.ComparisonOp = {
* A comparison expression (e.g. `foo >= 42`, `bar != "chicken"`). * A comparison expression (e.g. `foo >= 42`, `bar != "chicken"`).
* *
* @constructor * @constructor
* @extends {ol.expression.Expression} * @extends {ol.expr.Expression}
* @param {ol.expression.ComparisonOp} operator Comparison operator. * @param {ol.expr.ComparisonOp} operator Comparison operator.
* @param {ol.expression.Expression} left Left expression. * @param {ol.expr.Expression} left Left expression.
* @param {ol.expression.Expression} right Right expression. * @param {ol.expr.Expression} right Right expression.
*/ */
ol.expression.Comparison = function(operator, left, right) { ol.expr.Comparison = function(operator, left, right) {
/** /**
* @type {ol.expression.ComparisonOp} * @type {ol.expr.ComparisonOp}
* @private * @private
*/ */
this.operator_ = operator; this.operator_ = operator;
/** /**
* @type {ol.expression.Expression} * @type {ol.expr.Expression}
* @private * @private
*/ */
this.left_ = left; this.left_ = left;
/** /**
* @type {ol.expression.Expression} * @type {ol.expr.Expression}
* @private * @private
*/ */
this.right_ = right; this.right_ = right;
}; };
goog.inherits(ol.expression.Comparison, ol.expression.Expression); goog.inherits(ol.expr.Comparison, ol.expr.Expression);
/** /**
@@ -161,10 +161,10 @@ goog.inherits(ol.expression.Comparison, ol.expression.Expression);
* @param {string} candidate Operator to test. * @param {string} candidate Operator to test.
* @return {boolean} The operator is valid. * @return {boolean} The operator is valid.
*/ */
ol.expression.Comparison.isValidOp = (function() { ol.expr.Comparison.isValidOp = (function() {
var valid = {}; var valid = {};
for (var key in ol.expression.ComparisonOp) { for (var key in ol.expr.ComparisonOp) {
valid[ol.expression.ComparisonOp[key]] = true; valid[ol.expr.ComparisonOp[key]] = true;
} }
return function isValidOp(candidate) { return function isValidOp(candidate) {
return !!valid[candidate]; return !!valid[candidate];
@@ -175,35 +175,35 @@ ol.expression.Comparison.isValidOp = (function() {
/** /**
* @inheritDoc * @inheritDoc
*/ */
ol.expression.Comparison.prototype.evaluate = function(opt_scope, opt_fns, ol.expr.Comparison.prototype.evaluate = function(opt_scope, opt_fns,
opt_this) { opt_this) {
var result; var result;
var rightVal = this.right_.evaluate(opt_scope, opt_fns, opt_this); var rightVal = this.right_.evaluate(opt_scope, opt_fns, opt_this);
var leftVal = this.left_.evaluate(opt_scope, opt_fns, opt_this); var leftVal = this.left_.evaluate(opt_scope, opt_fns, opt_this);
switch (this.operator_) { switch (this.operator_) {
case ol.expression.ComparisonOp.EQ: case ol.expr.ComparisonOp.EQ:
result = leftVal == rightVal; result = leftVal == rightVal;
break; break;
case ol.expression.ComparisonOp.NEQ: case ol.expr.ComparisonOp.NEQ:
result = leftVal != rightVal; result = leftVal != rightVal;
break; break;
case ol.expression.ComparisonOp.STRICT_EQ: case ol.expr.ComparisonOp.STRICT_EQ:
result = leftVal === rightVal; result = leftVal === rightVal;
break; break;
case ol.expression.ComparisonOp.STRICT_NEQ: case ol.expr.ComparisonOp.STRICT_NEQ:
result = leftVal !== rightVal; result = leftVal !== rightVal;
break; break;
case ol.expression.ComparisonOp.GT: case ol.expr.ComparisonOp.GT:
result = leftVal > rightVal; result = leftVal > rightVal;
break; break;
case ol.expression.ComparisonOp.LT: case ol.expr.ComparisonOp.LT:
result = leftVal < rightVal; result = leftVal < rightVal;
break; break;
case ol.expression.ComparisonOp.GTE: case ol.expr.ComparisonOp.GTE:
result = leftVal >= rightVal; result = leftVal >= rightVal;
break; break;
case ol.expression.ComparisonOp.LTE: case ol.expr.ComparisonOp.LTE:
result = leftVal <= rightVal; result = leftVal <= rightVal;
break; break;
default: default:
@@ -217,25 +217,25 @@ ol.expression.Comparison.prototype.evaluate = function(opt_scope, opt_fns,
* Get the comparison operator. * Get the comparison operator.
* @return {string} The comparison operator. * @return {string} The comparison operator.
*/ */
ol.expression.Comparison.prototype.getOperator = function() { ol.expr.Comparison.prototype.getOperator = function() {
return this.operator_; return this.operator_;
}; };
/** /**
* Get the left expression. * Get the left expression.
* @return {ol.expression.Expression} The left expression. * @return {ol.expr.Expression} The left expression.
*/ */
ol.expression.Comparison.prototype.getLeft = function() { ol.expr.Comparison.prototype.getLeft = function() {
return this.left_; return this.left_;
}; };
/** /**
* Get the right expression. * Get the right expression.
* @return {ol.expression.Expression} The right expression. * @return {ol.expr.Expression} The right expression.
*/ */
ol.expression.Comparison.prototype.getRight = function() { ol.expr.Comparison.prototype.getRight = function() {
return this.right_; return this.right_;
}; };
@@ -245,10 +245,10 @@ ol.expression.Comparison.prototype.getRight = function() {
* An identifier expression (e.g. `foo`). * An identifier expression (e.g. `foo`).
* *
* @constructor * @constructor
* @extends {ol.expression.Expression} * @extends {ol.expr.Expression}
* @param {string} name An identifier name. * @param {string} name An identifier name.
*/ */
ol.expression.Identifier = function(name) { ol.expr.Identifier = function(name) {
/** /**
* @type {string} * @type {string}
@@ -257,13 +257,13 @@ ol.expression.Identifier = function(name) {
this.name_ = name; this.name_ = name;
}; };
goog.inherits(ol.expression.Identifier, ol.expression.Expression); goog.inherits(ol.expr.Identifier, ol.expr.Expression);
/** /**
* @inheritDoc * @inheritDoc
*/ */
ol.expression.Identifier.prototype.evaluate = function(opt_scope) { ol.expr.Identifier.prototype.evaluate = function(opt_scope) {
if (!goog.isDefAndNotNull(opt_scope)) { if (!goog.isDefAndNotNull(opt_scope)) {
throw new Error('Attempt to evaluate identifier with no scope'); throw new Error('Attempt to evaluate identifier with no scope');
} }
@@ -275,7 +275,7 @@ ol.expression.Identifier.prototype.evaluate = function(opt_scope) {
* Get the identifier name. * Get the identifier name.
* @return {string} The identifier name. * @return {string} The identifier name.
*/ */
ol.expression.Identifier.prototype.getName = function() { ol.expr.Identifier.prototype.getName = function() {
return this.name_; return this.name_;
}; };
@@ -285,10 +285,10 @@ ol.expression.Identifier.prototype.getName = function() {
* A literal expression (e.g. `"chicken"`, `42`, `true`, `null`). * A literal expression (e.g. `"chicken"`, `42`, `true`, `null`).
* *
* @constructor * @constructor
* @extends {ol.expression.Expression} * @extends {ol.expr.Expression}
* @param {string|number|boolean|null} value A literal value. * @param {string|number|boolean|null} value A literal value.
*/ */
ol.expression.Literal = function(value) { ol.expr.Literal = function(value) {
/** /**
* @type {string|number|boolean|null} * @type {string|number|boolean|null}
@@ -297,13 +297,13 @@ ol.expression.Literal = function(value) {
this.value_ = value; this.value_ = value;
}; };
goog.inherits(ol.expression.Literal, ol.expression.Expression); goog.inherits(ol.expr.Literal, ol.expr.Expression);
/** /**
* @inheritDoc * @inheritDoc
*/ */
ol.expression.Literal.prototype.evaluate = function() { ol.expr.Literal.prototype.evaluate = function() {
return this.value_; return this.value_;
}; };
@@ -312,7 +312,7 @@ ol.expression.Literal.prototype.evaluate = function() {
* Get the literal value. * Get the literal value.
* @return {string|number|boolean|null} The literal value. * @return {string|number|boolean|null} The literal value.
*/ */
ol.expression.Literal.prototype.getValue = function() { ol.expr.Literal.prototype.getValue = function() {
return this.value_; return this.value_;
}; };
@@ -320,7 +320,7 @@ ol.expression.Literal.prototype.getValue = function() {
/** /**
* @enum {string} * @enum {string}
*/ */
ol.expression.LogicalOp = { ol.expr.LogicalOp = {
AND: '&&', AND: '&&',
OR: '||' OR: '||'
}; };
@@ -331,33 +331,33 @@ ol.expression.LogicalOp = {
* A binary logical expression (e.g. `foo && bar`, `bar || "chicken"`). * A binary logical expression (e.g. `foo && bar`, `bar || "chicken"`).
* *
* @constructor * @constructor
* @extends {ol.expression.Expression} * @extends {ol.expr.Expression}
* @param {ol.expression.LogicalOp} operator Logical operator. * @param {ol.expr.LogicalOp} operator Logical operator.
* @param {ol.expression.Expression} left Left expression. * @param {ol.expr.Expression} left Left expression.
* @param {ol.expression.Expression} right Right expression. * @param {ol.expr.Expression} right Right expression.
*/ */
ol.expression.Logical = function(operator, left, right) { ol.expr.Logical = function(operator, left, right) {
/** /**
* @type {ol.expression.LogicalOp} * @type {ol.expr.LogicalOp}
* @private * @private
*/ */
this.operator_ = operator; this.operator_ = operator;
/** /**
* @type {ol.expression.Expression} * @type {ol.expr.Expression}
* @private * @private
*/ */
this.left_ = left; this.left_ = left;
/** /**
* @type {ol.expression.Expression} * @type {ol.expr.Expression}
* @private * @private
*/ */
this.right_ = right; this.right_ = right;
}; };
goog.inherits(ol.expression.Logical, ol.expression.Expression); goog.inherits(ol.expr.Logical, ol.expr.Expression);
/** /**
@@ -365,10 +365,10 @@ goog.inherits(ol.expression.Logical, ol.expression.Expression);
* @param {string} candidate Operator to test. * @param {string} candidate Operator to test.
* @return {boolean} The operator is valid. * @return {boolean} The operator is valid.
*/ */
ol.expression.Logical.isValidOp = (function() { ol.expr.Logical.isValidOp = (function() {
var valid = {}; var valid = {};
for (var key in ol.expression.LogicalOp) { for (var key in ol.expr.LogicalOp) {
valid[ol.expression.LogicalOp[key]] = true; valid[ol.expr.LogicalOp[key]] = true;
} }
return function isValidOp(candidate) { return function isValidOp(candidate) {
return !!valid[candidate]; return !!valid[candidate];
@@ -379,15 +379,15 @@ ol.expression.Logical.isValidOp = (function() {
/** /**
* @inheritDoc * @inheritDoc
*/ */
ol.expression.Logical.prototype.evaluate = function(opt_scope, opt_fns, ol.expr.Logical.prototype.evaluate = function(opt_scope, opt_fns,
opt_this) { opt_this) {
var result; var result;
var rightVal = this.right_.evaluate(opt_scope, opt_fns, opt_this); var rightVal = this.right_.evaluate(opt_scope, opt_fns, opt_this);
var leftVal = this.left_.evaluate(opt_scope, opt_fns, opt_this); var leftVal = this.left_.evaluate(opt_scope, opt_fns, opt_this);
if (this.operator_ === ol.expression.LogicalOp.AND) { if (this.operator_ === ol.expr.LogicalOp.AND) {
result = leftVal && rightVal; result = leftVal && rightVal;
} else if (this.operator_ === ol.expression.LogicalOp.OR) { } else if (this.operator_ === ol.expr.LogicalOp.OR) {
result = leftVal || rightVal; result = leftVal || rightVal;
} else { } else {
throw new Error('Unsupported logical operator: ' + this.operator_); throw new Error('Unsupported logical operator: ' + this.operator_);
@@ -400,25 +400,25 @@ ol.expression.Logical.prototype.evaluate = function(opt_scope, opt_fns,
* Get the logical operator. * Get the logical operator.
* @return {string} The logical operator. * @return {string} The logical operator.
*/ */
ol.expression.Logical.prototype.getOperator = function() { ol.expr.Logical.prototype.getOperator = function() {
return this.operator_; return this.operator_;
}; };
/** /**
* Get the left expression. * Get the left expression.
* @return {ol.expression.Expression} The left expression. * @return {ol.expr.Expression} The left expression.
*/ */
ol.expression.Logical.prototype.getLeft = function() { ol.expr.Logical.prototype.getLeft = function() {
return this.left_; return this.left_;
}; };
/** /**
* Get the right expression. * Get the right expression.
* @return {ol.expression.Expression} The right expression. * @return {ol.expr.Expression} The right expression.
*/ */
ol.expression.Logical.prototype.getRight = function() { ol.expr.Logical.prototype.getRight = function() {
return this.right_; return this.right_;
}; };
@@ -426,7 +426,7 @@ ol.expression.Logical.prototype.getRight = function() {
/** /**
* @enum {string} * @enum {string}
*/ */
ol.expression.MathOp = { ol.expr.MathOp = {
ADD: '+', ADD: '+',
SUBTRACT: '-', SUBTRACT: '-',
MULTIPLY: '*', MULTIPLY: '*',
@@ -440,33 +440,33 @@ ol.expression.MathOp = {
* A math expression (e.g. `foo + 42`, `bar % 10`). * A math expression (e.g. `foo + 42`, `bar % 10`).
* *
* @constructor * @constructor
* @extends {ol.expression.Expression} * @extends {ol.expr.Expression}
* @param {ol.expression.MathOp} operator Math operator. * @param {ol.expr.MathOp} operator Math operator.
* @param {ol.expression.Expression} left Left expression. * @param {ol.expr.Expression} left Left expression.
* @param {ol.expression.Expression} right Right expression. * @param {ol.expr.Expression} right Right expression.
*/ */
ol.expression.Math = function(operator, left, right) { ol.expr.Math = function(operator, left, right) {
/** /**
* @type {ol.expression.MathOp} * @type {ol.expr.MathOp}
* @private * @private
*/ */
this.operator_ = operator; this.operator_ = operator;
/** /**
* @type {ol.expression.Expression} * @type {ol.expr.Expression}
* @private * @private
*/ */
this.left_ = left; this.left_ = left;
/** /**
* @type {ol.expression.Expression} * @type {ol.expr.Expression}
* @private * @private
*/ */
this.right_ = right; this.right_ = right;
}; };
goog.inherits(ol.expression.Math, ol.expression.Expression); goog.inherits(ol.expr.Math, ol.expr.Expression);
/** /**
@@ -474,10 +474,10 @@ goog.inherits(ol.expression.Math, ol.expression.Expression);
* @param {string} candidate Operator to test. * @param {string} candidate Operator to test.
* @return {boolean} The operator is valid. * @return {boolean} The operator is valid.
*/ */
ol.expression.Math.isValidOp = (function() { ol.expr.Math.isValidOp = (function() {
var valid = {}; var valid = {};
for (var key in ol.expression.MathOp) { for (var key in ol.expr.MathOp) {
valid[ol.expression.MathOp[key]] = true; valid[ol.expr.MathOp[key]] = true;
} }
return function isValidOp(candidate) { return function isValidOp(candidate) {
return !!valid[candidate]; return !!valid[candidate];
@@ -488,7 +488,7 @@ ol.expression.Math.isValidOp = (function() {
/** /**
* @inheritDoc * @inheritDoc
*/ */
ol.expression.Math.prototype.evaluate = function(opt_scope, opt_fns, opt_this) { ol.expr.Math.prototype.evaluate = function(opt_scope, opt_fns, opt_this) {
var result; var result;
var rightVal = this.right_.evaluate(opt_scope, opt_fns, opt_this); var rightVal = this.right_.evaluate(opt_scope, opt_fns, opt_this);
var leftVal = this.left_.evaluate(opt_scope, opt_fns, opt_this); var leftVal = this.left_.evaluate(opt_scope, opt_fns, opt_this);
@@ -499,19 +499,19 @@ ol.expression.Math.prototype.evaluate = function(opt_scope, opt_fns, opt_this) {
*/ */
switch (this.operator_) { switch (this.operator_) {
case ol.expression.MathOp.ADD: case ol.expr.MathOp.ADD:
result = leftVal + rightVal; result = leftVal + rightVal;
break; break;
case ol.expression.MathOp.SUBTRACT: case ol.expr.MathOp.SUBTRACT:
result = Number(leftVal) - Number(rightVal); result = Number(leftVal) - Number(rightVal);
break; break;
case ol.expression.MathOp.MULTIPLY: case ol.expr.MathOp.MULTIPLY:
result = Number(leftVal) * Number(rightVal); result = Number(leftVal) * Number(rightVal);
break; break;
case ol.expression.MathOp.DIVIDE: case ol.expr.MathOp.DIVIDE:
result = Number(leftVal) / Number(rightVal); result = Number(leftVal) / Number(rightVal);
break; break;
case ol.expression.MathOp.MOD: case ol.expr.MathOp.MOD:
result = Number(leftVal) % Number(rightVal); result = Number(leftVal) % Number(rightVal);
break; break;
default: default:
@@ -525,25 +525,25 @@ ol.expression.Math.prototype.evaluate = function(opt_scope, opt_fns, opt_this) {
* Get the math operator. * Get the math operator.
* @return {string} The math operator. * @return {string} The math operator.
*/ */
ol.expression.Math.prototype.getOperator = function() { ol.expr.Math.prototype.getOperator = function() {
return this.operator_; return this.operator_;
}; };
/** /**
* Get the left expression. * Get the left expression.
* @return {ol.expression.Expression} The left expression. * @return {ol.expr.Expression} The left expression.
*/ */
ol.expression.Math.prototype.getLeft = function() { ol.expr.Math.prototype.getLeft = function() {
return this.left_; return this.left_;
}; };
/** /**
* Get the right expression. * Get the right expression.
* @return {ol.expression.Expression} The right expression. * @return {ol.expr.Expression} The right expression.
*/ */
ol.expression.Math.prototype.getRight = function() { ol.expr.Math.prototype.getRight = function() {
return this.right_; return this.right_;
}; };
@@ -553,33 +553,33 @@ ol.expression.Math.prototype.getRight = function() {
* A member expression (e.g. `foo.bar`). * A member expression (e.g. `foo.bar`).
* *
* @constructor * @constructor
* @extends {ol.expression.Expression} * @extends {ol.expr.Expression}
* @param {ol.expression.Expression} object An expression that resolves to an * @param {ol.expr.Expression} object An expression that resolves to an
* object. * object.
* @param {ol.expression.Identifier} property Identifier with name of property. * @param {ol.expr.Identifier} property Identifier with name of property.
*/ */
ol.expression.Member = function(object, property) { ol.expr.Member = function(object, property) {
/** /**
* @type {ol.expression.Expression} * @type {ol.expr.Expression}
* @private * @private
*/ */
this.object_ = object; this.object_ = object;
/** /**
* @type {ol.expression.Identifier} * @type {ol.expr.Identifier}
* @private * @private
*/ */
this.property_ = property; this.property_ = property;
}; };
goog.inherits(ol.expression.Member, ol.expression.Expression); goog.inherits(ol.expr.Member, ol.expr.Expression);
/** /**
* @inheritDoc * @inheritDoc
*/ */
ol.expression.Member.prototype.evaluate = function(opt_scope, opt_fns, ol.expr.Member.prototype.evaluate = function(opt_scope, opt_fns,
opt_this) { opt_this) {
var obj = this.object_.evaluate(opt_scope, opt_fns, opt_this); var obj = this.object_.evaluate(opt_scope, opt_fns, opt_this);
if (!goog.isObject(obj)) { if (!goog.isObject(obj)) {
@@ -592,18 +592,18 @@ ol.expression.Member.prototype.evaluate = function(opt_scope, opt_fns,
/** /**
* Get the object expression. * Get the object expression.
* @return {ol.expression.Expression} The object. * @return {ol.expr.Expression} The object.
*/ */
ol.expression.Member.prototype.getObject = function() { ol.expr.Member.prototype.getObject = function() {
return this.object_; return this.object_;
}; };
/** /**
* Get the property expression. * Get the property expression.
* @return {ol.expression.Identifier} The property. * @return {ol.expr.Identifier} The property.
*/ */
ol.expression.Member.prototype.getProperty = function() { ol.expr.Member.prototype.getProperty = function() {
return this.property_; return this.property_;
}; };
@@ -613,33 +613,33 @@ ol.expression.Member.prototype.getProperty = function() {
* A logical not expression (e.g. `!foo`). * A logical not expression (e.g. `!foo`).
* *
* @constructor * @constructor
* @extends {ol.expression.Expression} * @extends {ol.expr.Expression}
* @param {ol.expression.Expression} argument Expression to negate. * @param {ol.expr.Expression} argument Expression to negate.
*/ */
ol.expression.Not = function(argument) { ol.expr.Not = function(argument) {
/** /**
* @type {ol.expression.Expression} * @type {ol.expr.Expression}
* @private * @private
*/ */
this.argument_ = argument; this.argument_ = argument;
}; };
goog.inherits(ol.expression.Not, ol.expression.Expression); goog.inherits(ol.expr.Not, ol.expr.Expression);
/** /**
* @inheritDoc * @inheritDoc
*/ */
ol.expression.Not.prototype.evaluate = function(opt_scope, opt_fns, opt_this) { ol.expr.Not.prototype.evaluate = function(opt_scope, opt_fns, opt_this) {
return !this.argument_.evaluate(opt_scope, opt_fns, opt_this); return !this.argument_.evaluate(opt_scope, opt_fns, opt_this);
}; };
/** /**
* Get the argument (the negated expression). * Get the argument (the negated expression).
* @return {ol.expression.Expression} The argument. * @return {ol.expr.Expression} The argument.
*/ */
ol.expression.Not.prototype.getArgument = function() { ol.expr.Not.prototype.getArgument = function() {
return this.argument_; return this.argument_;
}; };

292
src/ol/expression/lexer.js → src/ol/expr/lexer.js
View File

@@ -13,11 +13,11 @@
* Copyright (C) 2011 Ariya Hidayat <ariya.hidayat@gmail.com> * Copyright (C) 2011 Ariya Hidayat <ariya.hidayat@gmail.com>
*/ */
goog.provide('ol.expression.Char'); // TODO: remove this - see #785 goog.provide('ol.expr.Char'); // TODO: remove this - see #785
goog.provide('ol.expression.Lexer'); goog.provide('ol.expr.Lexer');
goog.provide('ol.expression.Token'); goog.provide('ol.expr.Token');
goog.provide('ol.expression.TokenType'); goog.provide('ol.expr.TokenType');
goog.provide('ol.expression.UnexpectedToken'); goog.provide('ol.expr.UnexpectedToken');
goog.require('goog.asserts'); goog.require('goog.asserts');
goog.require('goog.debug.Error'); goog.require('goog.debug.Error');
@@ -26,7 +26,7 @@ goog.require('goog.debug.Error');
/** /**
* @enum {number} * @enum {number}
*/ */
ol.expression.Char = { ol.expr.Char = {
AMPERSAND: 38, AMPERSAND: 38,
BACKSLASH: 92, BACKSLASH: 92,
BANG: 33, // ! BANG: 33, // !
@@ -76,7 +76,7 @@ ol.expression.Char = {
/** /**
* @enum {string} * @enum {string}
*/ */
ol.expression.TokenType = { ol.expr.TokenType = {
BOOLEAN_LITERAL: 'Boolean', BOOLEAN_LITERAL: 'Boolean',
EOF: '<end>', EOF: '<end>',
IDENTIFIER: 'Identifier', IDENTIFIER: 'Identifier',
@@ -90,11 +90,11 @@ ol.expression.TokenType = {
/** /**
* @typedef {{type: (ol.expression.TokenType), * @typedef {{type: (ol.expr.TokenType),
* value: (string|number|boolean|null), * value: (string|number|boolean|null),
* index: (number)}} * index: (number)}}
*/ */
ol.expression.Token; ol.expr.Token;
@@ -105,7 +105,7 @@ ol.expression.Token;
* @constructor * @constructor
* @param {string} source Source code. * @param {string} source Source code.
*/ */
ol.expression.Lexer = function(source) { ol.expr.Lexer = function(source) {
/** /**
* Source code. * Source code.
@@ -142,11 +142,11 @@ ol.expression.Lexer = function(source) {
* Scan the next token and throw if it isn't a punctuator that matches input. * Scan the next token and throw if it isn't a punctuator that matches input.
* @param {string} value Token value. * @param {string} value Token value.
*/ */
ol.expression.Lexer.prototype.expect = function(value) { ol.expr.Lexer.prototype.expect = function(value) {
var match = this.match(value); var match = this.match(value);
if (!match) { if (!match) {
throw new ol.expression.UnexpectedToken({ throw new ol.expr.UnexpectedToken({
type: ol.expression.TokenType.UNKNOWN, type: ol.expr.TokenType.UNKNOWN,
value: this.getCurrentChar_(), value: this.getCurrentChar_(),
index: this.index_ index: this.index_
}); });
@@ -161,7 +161,7 @@ ol.expression.Lexer.prototype.expect = function(value) {
* @param {number} delta Delta by which the index is advanced. * @param {number} delta Delta by which the index is advanced.
* @private * @private
*/ */
ol.expression.Lexer.prototype.increment_ = function(delta) { ol.expr.Lexer.prototype.increment_ = function(delta) {
this.index_ += delta; this.index_ += delta;
}; };
@@ -173,10 +173,10 @@ ol.expression.Lexer.prototype.increment_ = function(delta) {
* @return {boolean} The character is a decimal digit. * @return {boolean} The character is a decimal digit.
* @private * @private
*/ */
ol.expression.Lexer.prototype.isDecimalDigit_ = function(code) { ol.expr.Lexer.prototype.isDecimalDigit_ = function(code) {
return ( return (
code >= ol.expression.Char.DIGIT_0 && code >= ol.expr.Char.DIGIT_0 &&
code <= ol.expression.Char.DIGIT_9); code <= ol.expr.Char.DIGIT_9);
}; };
@@ -187,7 +187,7 @@ ol.expression.Lexer.prototype.isDecimalDigit_ = function(code) {
* @return {boolean} The identifier is a future reserved word. * @return {boolean} The identifier is a future reserved word.
* @private * @private
*/ */
ol.expression.Lexer.prototype.isFutureReservedWord_ = function(id) { ol.expr.Lexer.prototype.isFutureReservedWord_ = function(id) {
return ( return (
id === 'class' || id === 'class' ||
id === 'enum' || id === 'enum' ||
@@ -205,12 +205,12 @@ ol.expression.Lexer.prototype.isFutureReservedWord_ = function(id) {
* @return {boolean} The character is a hex digit. * @return {boolean} The character is a hex digit.
* @private * @private
*/ */
ol.expression.Lexer.prototype.isHexDigit_ = function(code) { ol.expr.Lexer.prototype.isHexDigit_ = function(code) {
return this.isDecimalDigit_(code) || return this.isDecimalDigit_(code) ||
(code >= ol.expression.Char.LOWER_A && (code >= ol.expr.Char.LOWER_A &&
code <= ol.expression.Char.LOWER_F) || code <= ol.expr.Char.LOWER_F) ||
(code >= ol.expression.Char.UPPER_A && (code >= ol.expr.Char.UPPER_A &&
code <= ol.expression.Char.UPPER_F); code <= ol.expr.Char.UPPER_F);
}; };
@@ -222,10 +222,10 @@ ol.expression.Lexer.prototype.isHexDigit_ = function(code) {
* @return {boolean} The character is a valid identifier part. * @return {boolean} The character is a valid identifier part.
* @private * @private
*/ */
ol.expression.Lexer.prototype.isIdentifierPart_ = function(code) { ol.expr.Lexer.prototype.isIdentifierPart_ = function(code) {
return this.isIdentifierStart_(code) || return this.isIdentifierStart_(code) ||
(code >= ol.expression.Char.DIGIT_0 && (code >= ol.expr.Char.DIGIT_0 &&
code <= ol.expression.Char.DIGIT_9); code <= ol.expr.Char.DIGIT_9);
}; };
@@ -237,20 +237,20 @@ ol.expression.Lexer.prototype.isIdentifierPart_ = function(code) {
* @return {boolean} The character is a valid identifier start. * @return {boolean} The character is a valid identifier start.
* @private * @private
*/ */
ol.expression.Lexer.prototype.isIdentifierStart_ = function(code) { ol.expr.Lexer.prototype.isIdentifierStart_ = function(code) {
return (code === ol.expression.Char.DOLLAR) || return (code === ol.expr.Char.DOLLAR) ||
(code === ol.expression.Char.UNDERSCORE) || (code === ol.expr.Char.UNDERSCORE) ||
(code >= ol.expression.Char.UPPER_A && (code >= ol.expr.Char.UPPER_A &&
code <= ol.expression.Char.UPPER_Z) || code <= ol.expr.Char.UPPER_Z) ||
(code >= ol.expression.Char.LOWER_A && (code >= ol.expr.Char.LOWER_A &&
code <= ol.expression.Char.LOWER_Z); code <= ol.expr.Char.LOWER_Z);
}; };
/** /**
* Determine if the given identifier is an ECMAScript keyword. These cannot * Determine if the given identifier is an ECMAScript keyword. These cannot
* be used as identifiers in programs. There is no real reason these could not * be used as identifiers in programs. There is no real reason these could not
* be used in ol expressions - but they are reserved for future use. * be used in ol.exprs - but they are reserved for future use.
* *
* http://www.ecma-international.org/ecma-262/5.1/#sec-7.6.1.1 * http://www.ecma-international.org/ecma-262/5.1/#sec-7.6.1.1
* *
@@ -258,7 +258,7 @@ ol.expression.Lexer.prototype.isIdentifierStart_ = function(code) {
* @return {boolean} The identifier is a keyword. * @return {boolean} The identifier is a keyword.
* @private * @private
*/ */
ol.expression.Lexer.prototype.isKeyword_ = function(id) { ol.expr.Lexer.prototype.isKeyword_ = function(id) {
return ( return (
id === 'break' || id === 'break' ||
id === 'case' || id === 'case' ||
@@ -296,11 +296,11 @@ ol.expression.Lexer.prototype.isKeyword_ = function(id) {
* @return {boolean} The character is a line terminator. * @return {boolean} The character is a line terminator.
* @private * @private
*/ */
ol.expression.Lexer.prototype.isLineTerminator_ = function(code) { ol.expr.Lexer.prototype.isLineTerminator_ = function(code) {
return (code === ol.expression.Char.LINE_FEED) || return (code === ol.expr.Char.LINE_FEED) ||
(code === ol.expression.Char.CARRIAGE_RETURN) || (code === ol.expr.Char.CARRIAGE_RETURN) ||
(code === ol.expression.Char.LINE_SEPARATOR) || (code === ol.expr.Char.LINE_SEPARATOR) ||
(code === ol.expression.Char.PARAGRAPH_SEPARATOR); (code === ol.expr.Char.PARAGRAPH_SEPARATOR);
}; };
@@ -311,10 +311,10 @@ ol.expression.Lexer.prototype.isLineTerminator_ = function(code) {
* @return {boolean} The character is an octal digit. * @return {boolean} The character is an octal digit.
* @private * @private
*/ */
ol.expression.Lexer.prototype.isOctalDigit_ = function(code) { ol.expr.Lexer.prototype.isOctalDigit_ = function(code) {
return ( return (
code >= ol.expression.Char.DIGIT_0 && code >= ol.expr.Char.DIGIT_0 &&
code <= ol.expression.Char.DIGIT_7); code <= ol.expr.Char.DIGIT_7);
}; };
@@ -325,12 +325,12 @@ ol.expression.Lexer.prototype.isOctalDigit_ = function(code) {
* @return {boolean} The character is whitespace. * @return {boolean} The character is whitespace.
* @private * @private
*/ */
ol.expression.Lexer.prototype.isWhitespace_ = function(code) { ol.expr.Lexer.prototype.isWhitespace_ = function(code) {
return (code === ol.expression.Char.SPACE) || return (code === ol.expr.Char.SPACE) ||
(code === ol.expression.Char.TAB) || (code === ol.expr.Char.TAB) ||
(code === ol.expression.Char.VERTICAL_TAB) || (code === ol.expr.Char.VERTICAL_TAB) ||
(code === ol.expression.Char.FORM_FEED) || (code === ol.expr.Char.FORM_FEED) ||
(code === ol.expression.Char.NONBREAKING_SPACE) || (code === ol.expr.Char.NONBREAKING_SPACE) ||
(code >= 0x1680 && '\u1680\u180E\u2000\u2001\u2002\u2003\u2004\u2005' + (code >= 0x1680 && '\u1680\u180E\u2000\u2001\u2002\u2003\u2004\u2005' +
'\u2006\u2007\u2008\u2009\u200A\u202F\u205F\u3000\uFEFF' '\u2006\u2007\u2008\u2009\u200A\u202F\u205F\u3000\uFEFF'
.indexOf(String.fromCharCode(code)) > 0); .indexOf(String.fromCharCode(code)) > 0);
@@ -344,7 +344,7 @@ ol.expression.Lexer.prototype.isWhitespace_ = function(code) {
* @return {number} The character code. * @return {number} The character code.
* @private * @private
*/ */
ol.expression.Lexer.prototype.getCharCode_ = function(delta) { ol.expr.Lexer.prototype.getCharCode_ = function(delta) {
return this.source_.charCodeAt(this.index_ + delta); return this.source_.charCodeAt(this.index_ + delta);
}; };
@@ -355,7 +355,7 @@ ol.expression.Lexer.prototype.getCharCode_ = function(delta) {
* @return {string} The current character. * @return {string} The current character.
* @private * @private
*/ */
ol.expression.Lexer.prototype.getCurrentChar_ = function() { ol.expr.Lexer.prototype.getCurrentChar_ = function() {
return this.source_[this.index_]; return this.source_[this.index_];
}; };
@@ -366,7 +366,7 @@ ol.expression.Lexer.prototype.getCurrentChar_ = function() {
* @return {number} The current character code. * @return {number} The current character code.
* @private * @private
*/ */
ol.expression.Lexer.prototype.getCurrentCharCode_ = function() { ol.expr.Lexer.prototype.getCurrentCharCode_ = function() {
return this.getCharCode_(0); return this.getCharCode_(0);
}; };
@@ -376,10 +376,10 @@ ol.expression.Lexer.prototype.getCurrentCharCode_ = function() {
* @param {string} value Punctuator value. * @param {string} value Punctuator value.
* @return {boolean} The token matches. * @return {boolean} The token matches.
*/ */
ol.expression.Lexer.prototype.match = function(value) { ol.expr.Lexer.prototype.match = function(value) {
var token = this.peek(); var token = this.peek();
return ( return (
token.type === ol.expression.TokenType.PUNCTUATOR && token.type === ol.expr.TokenType.PUNCTUATOR &&
token.value === value); token.value === value);
}; };
@@ -387,28 +387,28 @@ ol.expression.Lexer.prototype.match = function(value) {
/** /**
* Scan the next token. * Scan the next token.
* *
* @return {ol.expression.Token} Next token. * @return {ol.expr.Token} Next token.
*/ */
ol.expression.Lexer.prototype.next = function() { ol.expr.Lexer.prototype.next = function() {
var code = this.skipWhitespace_(); var code = this.skipWhitespace_();
if (this.index_ >= this.length_) { if (this.index_ >= this.length_) {
return { return {
type: ol.expression.TokenType.EOF, type: ol.expr.TokenType.EOF,
value: null, value: null,
index: this.index_ index: this.index_
}; };
} }
// check for common punctuation // check for common punctuation
if (code === ol.expression.Char.LEFT_PAREN || if (code === ol.expr.Char.LEFT_PAREN ||
code === ol.expression.Char.RIGHT_PAREN) { code === ol.expr.Char.RIGHT_PAREN) {
return this.scanPunctuator_(code); return this.scanPunctuator_(code);
} }
// check for string literal // check for string literal
if (code === ol.expression.Char.SINGLE_QUOTE || if (code === ol.expr.Char.SINGLE_QUOTE ||
code === ol.expression.Char.DOUBLE_QUOTE) { code === ol.expr.Char.DOUBLE_QUOTE) {
return this.scanStringLiteral_(code); return this.scanStringLiteral_(code);
} }
@@ -418,7 +418,7 @@ ol.expression.Lexer.prototype.next = function() {
} }
// check dot punctuation or decimal // check dot punctuation or decimal
if (code === ol.expression.Char.DOT) { if (code === ol.expr.Char.DOT) {
if (this.isDecimalDigit_(this.getCharCode_(1))) { if (this.isDecimalDigit_(this.getCharCode_(1))) {
return this.scanNumericLiteral_(code); return this.scanNumericLiteral_(code);
} }
@@ -438,9 +438,9 @@ ol.expression.Lexer.prototype.next = function() {
/** /**
* Peek at the next token, but don't advance the index. * Peek at the next token, but don't advance the index.
* *
* @return {ol.expression.Token} The upcoming token. * @return {ol.expr.Token} The upcoming token.
*/ */
ol.expression.Lexer.prototype.peek = function() { ol.expr.Lexer.prototype.peek = function() {
var currentIndex = this.index_; var currentIndex = this.index_;
var token = this.next(); var token = this.next();
this.nextIndex_ = this.index_; this.nextIndex_ = this.index_;
@@ -453,10 +453,10 @@ ol.expression.Lexer.prototype.peek = function() {
* Scan hex literal as numeric token. * Scan hex literal as numeric token.
* *
* @param {number} code The current character code. * @param {number} code The current character code.
* @return {ol.expression.Token} Numeric literal token. * @return {ol.expr.Token} Numeric literal token.
* @private * @private
*/ */
ol.expression.Lexer.prototype.scanHexLiteral_ = function(code) { ol.expr.Lexer.prototype.scanHexLiteral_ = function(code) {
var str = ''; var str = '';
var start = this.index_ - 2; var start = this.index_ - 2;
@@ -470,8 +470,8 @@ ol.expression.Lexer.prototype.scanHexLiteral_ = function(code) {
} }
if (str.length === 0 || this.isIdentifierStart_(code)) { if (str.length === 0 || this.isIdentifierStart_(code)) {
throw new ol.expression.UnexpectedToken({ throw new ol.expr.UnexpectedToken({
type: ol.expression.TokenType.UNKNOWN, type: ol.expr.TokenType.UNKNOWN,
value: String.fromCharCode(code), value: String.fromCharCode(code),
index: this.index_ index: this.index_
}); });
@@ -480,7 +480,7 @@ ol.expression.Lexer.prototype.scanHexLiteral_ = function(code) {
goog.asserts.assert(!isNaN(parseInt('0x' + str, 16)), 'Valid hex: ' + str); goog.asserts.assert(!isNaN(parseInt('0x' + str, 16)), 'Valid hex: ' + str);
return { return {
type: ol.expression.TokenType.NUMERIC_LITERAL, type: ol.expr.TokenType.NUMERIC_LITERAL,
value: parseInt('0x' + str, 16), value: parseInt('0x' + str, 16),
index: start index: start
}; };
@@ -491,10 +491,10 @@ ol.expression.Lexer.prototype.scanHexLiteral_ = function(code) {
* Scan identifier token. * Scan identifier token.
* *
* @param {number} code The current character code. * @param {number} code The current character code.
* @return {ol.expression.Token} Identifier token. * @return {ol.expr.Token} Identifier token.
* @private * @private
*/ */
ol.expression.Lexer.prototype.scanIdentifier_ = function(code) { ol.expr.Lexer.prototype.scanIdentifier_ = function(code) {
goog.asserts.assert(this.isIdentifierStart_(code), goog.asserts.assert(this.isIdentifierStart_(code),
'Must be called with a valid identifier'); 'Must be called with a valid identifier');
@@ -513,15 +513,15 @@ ol.expression.Lexer.prototype.scanIdentifier_ = function(code) {
var type; var type;
if (id.length === 1) { if (id.length === 1) {
type = ol.expression.TokenType.IDENTIFIER; type = ol.expr.TokenType.IDENTIFIER;
} else if (this.isKeyword_(id)) { } else if (this.isKeyword_(id)) {
type = ol.expression.TokenType.KEYWORD; type = ol.expr.TokenType.KEYWORD;
} else if (id === 'null') { } else if (id === 'null') {
type = ol.expression.TokenType.NULL_LITERAL; type = ol.expr.TokenType.NULL_LITERAL;
} else if (id === 'true' || id === 'false') { } else if (id === 'true' || id === 'false') {
type = ol.expression.TokenType.BOOLEAN_LITERAL; type = ol.expr.TokenType.BOOLEAN_LITERAL;
} else { } else {
type = ol.expression.TokenType.IDENTIFIER; type = ol.expr.TokenType.IDENTIFIER;
} }
return { return {
@@ -537,26 +537,26 @@ ol.expression.Lexer.prototype.scanIdentifier_ = function(code) {
* http://www.ecma-international.org/ecma-262/5.1/#sec-7.8.3 * http://www.ecma-international.org/ecma-262/5.1/#sec-7.8.3
* *
* @param {number} code The current character code. * @param {number} code The current character code.
* @return {ol.expression.Token} Numeric literal token. * @return {ol.expr.Token} Numeric literal token.
* @private * @private
*/ */
ol.expression.Lexer.prototype.scanNumericLiteral_ = function(code) { ol.expr.Lexer.prototype.scanNumericLiteral_ = function(code) {
goog.asserts.assert( goog.asserts.assert(
code === ol.expression.Char.DOT || this.isDecimalDigit_(code), code === ol.expr.Char.DOT || this.isDecimalDigit_(code),
'Valid start for numeric literal: ' + String.fromCharCode(code)); 'Valid start for numeric literal: ' + String.fromCharCode(code));
// start assembling numeric string // start assembling numeric string
var str = ''; var str = '';
var start = this.index_; var start = this.index_;
if (code !== ol.expression.Char.DOT) { if (code !== ol.expr.Char.DOT) {
if (code === ol.expression.Char.DIGIT_0) { if (code === ol.expr.Char.DIGIT_0) {
var nextCode = this.getCharCode_(1); var nextCode = this.getCharCode_(1);
// hex literals start with 0X or 0x // hex literals start with 0X or 0x
if (nextCode === ol.expression.Char.UPPER_X || if (nextCode === ol.expr.Char.UPPER_X ||
nextCode === ol.expression.Char.LOWER_X) { nextCode === ol.expr.Char.LOWER_X) {
this.increment_(2); this.increment_(2);
return this.scanHexLiteral_(this.getCurrentCharCode_()); return this.scanHexLiteral_(this.getCurrentCharCode_());
} }
@@ -569,8 +569,8 @@ ol.expression.Lexer.prototype.scanNumericLiteral_ = function(code) {
// numbers like 09 not allowed // numbers like 09 not allowed
if (this.isDecimalDigit_(nextCode)) { if (this.isDecimalDigit_(nextCode)) {
throw new ol.expression.UnexpectedToken({ throw new ol.expr.UnexpectedToken({
type: ol.expression.TokenType.UNKNOWN, type: ol.expr.TokenType.UNKNOWN,
value: String.fromCharCode(nextCode), value: String.fromCharCode(nextCode),
index: this.index_ index: this.index_
}); });
@@ -586,7 +586,7 @@ ol.expression.Lexer.prototype.scanNumericLiteral_ = function(code) {
} }
// scan fractional part // scan fractional part
if (code === ol.expression.Char.DOT) { if (code === ol.expr.Char.DOT) {
str += String.fromCharCode(code); str += String.fromCharCode(code);
this.increment_(1); this.increment_(1);
code = this.getCurrentCharCode_(); code = this.getCurrentCharCode_();
@@ -600,22 +600,22 @@ ol.expression.Lexer.prototype.scanNumericLiteral_ = function(code) {
} }
// scan exponent // scan exponent
if (code === ol.expression.Char.UPPER_E || if (code === ol.expr.Char.UPPER_E ||
code === ol.expression.Char.LOWER_E) { code === ol.expr.Char.LOWER_E) {
str += 'E'; str += 'E';
this.increment_(1); this.increment_(1);
code = this.getCurrentCharCode_(); code = this.getCurrentCharCode_();
if (code === ol.expression.Char.PLUS || if (code === ol.expr.Char.PLUS ||
code === ol.expression.Char.MINUS) { code === ol.expr.Char.MINUS) {
str += String.fromCharCode(code); str += String.fromCharCode(code);
this.increment_(1); this.increment_(1);
code = this.getCurrentCharCode_(); code = this.getCurrentCharCode_();
} }
if (!this.isDecimalDigit_(code)) { if (!this.isDecimalDigit_(code)) {
throw new ol.expression.UnexpectedToken({ throw new ol.expr.UnexpectedToken({
type: ol.expression.TokenType.UNKNOWN, type: ol.expr.TokenType.UNKNOWN,
value: String.fromCharCode(code), value: String.fromCharCode(code),
index: this.index_ index: this.index_
}); });
@@ -630,8 +630,8 @@ ol.expression.Lexer.prototype.scanNumericLiteral_ = function(code) {
} }
if (this.isIdentifierStart_(code)) { if (this.isIdentifierStart_(code)) {
throw new ol.expression.UnexpectedToken({ throw new ol.expr.UnexpectedToken({
type: ol.expression.TokenType.UNKNOWN, type: ol.expr.TokenType.UNKNOWN,
value: String.fromCharCode(code), value: String.fromCharCode(code),
index: this.index_ index: this.index_
}); });
@@ -640,7 +640,7 @@ ol.expression.Lexer.prototype.scanNumericLiteral_ = function(code) {
goog.asserts.assert(!isNaN(parseFloat(str)), 'Valid number: ' + str); goog.asserts.assert(!isNaN(parseFloat(str)), 'Valid number: ' + str);
return { return {
type: ol.expression.TokenType.NUMERIC_LITERAL, type: ol.expr.TokenType.NUMERIC_LITERAL,
value: parseFloat(str), value: parseFloat(str),
index: start index: start
}; };
@@ -652,10 +652,10 @@ ol.expression.Lexer.prototype.scanNumericLiteral_ = function(code) {
* Scan octal literal as numeric token. * Scan octal literal as numeric token.
* *
* @param {number} code The current character code. * @param {number} code The current character code.
* @return {ol.expression.Token} Numeric literal token. * @return {ol.expr.Token} Numeric literal token.
* @private * @private
*/ */
ol.expression.Lexer.prototype.scanOctalLiteral_ = function(code) { ol.expr.Lexer.prototype.scanOctalLiteral_ = function(code) {
goog.asserts.assert(this.isOctalDigit_(code)); goog.asserts.assert(this.isOctalDigit_(code));
var str = '0' + String.fromCharCode(code); var str = '0' + String.fromCharCode(code);
@@ -674,8 +674,8 @@ ol.expression.Lexer.prototype.scanOctalLiteral_ = function(code) {
code = this.getCurrentCharCode_(); code = this.getCurrentCharCode_();
if (this.isIdentifierStart_(code) || if (this.isIdentifierStart_(code) ||
this.isDecimalDigit_(code)) { this.isDecimalDigit_(code)) {
throw new ol.expression.UnexpectedToken({ throw new ol.expr.UnexpectedToken({
type: ol.expression.TokenType.UNKNOWN, type: ol.expr.TokenType.UNKNOWN,
value: String.fromCharCode(code), value: String.fromCharCode(code),
index: this.index_ index: this.index_
}); });
@@ -684,7 +684,7 @@ ol.expression.Lexer.prototype.scanOctalLiteral_ = function(code) {
goog.asserts.assert(!isNaN(parseInt(str, 8)), 'Valid octal: ' + str); goog.asserts.assert(!isNaN(parseInt(str, 8)), 'Valid octal: ' + str);
return { return {
type: ol.expression.TokenType.NUMERIC_LITERAL, type: ol.expr.TokenType.NUMERIC_LITERAL,
value: parseInt(str, 8), value: parseInt(str, 8),
index: start index: start
}; };
@@ -695,28 +695,28 @@ ol.expression.Lexer.prototype.scanOctalLiteral_ = function(code) {
* Scan punctuator token (a subset of allowed tokens in 7.7). * Scan punctuator token (a subset of allowed tokens in 7.7).
* *
* @param {number} code The current character code. * @param {number} code The current character code.
* @return {ol.expression.Token} Punctuator token. * @return {ol.expr.Token} Punctuator token.
* @private * @private
*/ */
ol.expression.Lexer.prototype.scanPunctuator_ = function(code) { ol.expr.Lexer.prototype.scanPunctuator_ = function(code) {
var start = this.index_; var start = this.index_;
// single char punctuation that also doesn't start longer punctuation // single char punctuation that also doesn't start longer punctuation
// (we disallow assignment, so no += etc.) // (we disallow assignment, so no += etc.)
if (code === ol.expression.Char.DOT || if (code === ol.expr.Char.DOT ||
code === ol.expression.Char.LEFT_PAREN || code === ol.expr.Char.LEFT_PAREN ||
code === ol.expression.Char.RIGHT_PAREN || code === ol.expr.Char.RIGHT_PAREN ||
code === ol.expression.Char.COMMA || code === ol.expr.Char.COMMA ||
code === ol.expression.Char.PLUS || code === ol.expr.Char.PLUS ||
code === ol.expression.Char.MINUS || code === ol.expr.Char.MINUS ||
code === ol.expression.Char.STAR || code === ol.expr.Char.STAR ||
code === ol.expression.Char.SLASH || code === ol.expr.Char.SLASH ||
code === ol.expression.Char.PERCENT || code === ol.expr.Char.PERCENT ||
code === ol.expression.Char.TILDE) { code === ol.expr.Char.TILDE) {
this.increment_(1); this.increment_(1);
return { return {
type: ol.expression.TokenType.PUNCTUATOR, type: ol.expr.TokenType.PUNCTUATOR,
value: String.fromCharCode(code), value: String.fromCharCode(code),
index: start index: start
}; };
@@ -726,34 +726,34 @@ ol.expression.Lexer.prototype.scanPunctuator_ = function(code) {
var nextCode = this.getCharCode_(1); var nextCode = this.getCharCode_(1);
// assignment or comparison (and we don't allow assignment) // assignment or comparison (and we don't allow assignment)
if (nextCode === ol.expression.Char.EQUAL) { if (nextCode === ol.expr.Char.EQUAL) {
if (code === ol.expression.Char.BANG || code === ol.expression.Char.EQUAL) { if (code === ol.expr.Char.BANG || code === ol.expr.Char.EQUAL) {
// we're looking at !=, ==, !==, or === // we're looking at !=, ==, !==, or ===
this.increment_(2); this.increment_(2);
// check for triple // check for triple
if (this.getCurrentCharCode_() === ol.expression.Char.EQUAL) { if (this.getCurrentCharCode_() === ol.expr.Char.EQUAL) {
this.increment_(1); this.increment_(1);
return { return {
type: ol.expression.TokenType.PUNCTUATOR, type: ol.expr.TokenType.PUNCTUATOR,
value: String.fromCharCode(code) + '==', value: String.fromCharCode(code) + '==',
index: start index: start
}; };
} else { } else {
// != or == // != or ==
return { return {
type: ol.expression.TokenType.PUNCTUATOR, type: ol.expr.TokenType.PUNCTUATOR,
value: String.fromCharCode(code) + '=', value: String.fromCharCode(code) + '=',
index: start index: start
}; };
} }
} }
if (code === ol.expression.Char.GREATER || if (code === ol.expr.Char.GREATER ||
code === ol.expression.Char.LESS) { code === ol.expr.Char.LESS) {
this.increment_(2); this.increment_(2);
return { return {
type: ol.expression.TokenType.PUNCTUATOR, type: ol.expr.TokenType.PUNCTUATOR,
value: String.fromCharCode(code) + '=', value: String.fromCharCode(code) + '=',
index: start index: start
}; };
@@ -762,13 +762,13 @@ ol.expression.Lexer.prototype.scanPunctuator_ = function(code) {
// remaining 2-charcter punctuators are || and && // remaining 2-charcter punctuators are || and &&
if (code === nextCode && if (code === nextCode &&
(code === ol.expression.Char.PIPE || (code === ol.expr.Char.PIPE ||
code === ol.expression.Char.AMPERSAND)) { code === ol.expr.Char.AMPERSAND)) {
this.increment_(2); this.increment_(2);
var str = String.fromCharCode(code); var str = String.fromCharCode(code);
return { return {
type: ol.expression.TokenType.PUNCTUATOR, type: ol.expr.TokenType.PUNCTUATOR,
value: str + str, value: str + str,
index: start index: start
}; };
@@ -778,22 +778,22 @@ ol.expression.Lexer.prototype.scanPunctuator_ = function(code) {
// and the allowed 3-character punctuators (!==, ===) are already consumed // and the allowed 3-character punctuators (!==, ===) are already consumed
// other single character punctuators // other single character punctuators
if (code === ol.expression.Char.GREATER || if (code === ol.expr.Char.GREATER ||
code === ol.expression.Char.LESS || code === ol.expr.Char.LESS ||
code === ol.expression.Char.BANG || code === ol.expr.Char.BANG ||
code === ol.expression.Char.AMPERSAND || code === ol.expr.Char.AMPERSAND ||
code === ol.expression.Char.PIPE) { code === ol.expr.Char.PIPE) {
this.increment_(1); this.increment_(1);
return { return {
type: ol.expression.TokenType.PUNCTUATOR, type: ol.expr.TokenType.PUNCTUATOR,
value: String.fromCharCode(code), value: String.fromCharCode(code),
index: start index: start
}; };
} }
throw new ol.expression.UnexpectedToken({ throw new ol.expr.UnexpectedToken({
type: ol.expression.TokenType.UNKNOWN, type: ol.expr.TokenType.UNKNOWN,
value: String.fromCharCode(code), value: String.fromCharCode(code),
index: this.index_ index: this.index_
}); });
@@ -804,12 +804,12 @@ ol.expression.Lexer.prototype.scanPunctuator_ = function(code) {
* Scan string literal token. * Scan string literal token.
* *
* @param {number} quote The current character code. * @param {number} quote The current character code.
* @return {ol.expression.Token} String literal token. * @return {ol.expr.Token} String literal token.
* @private * @private
*/ */
ol.expression.Lexer.prototype.scanStringLiteral_ = function(quote) { ol.expr.Lexer.prototype.scanStringLiteral_ = function(quote) {
goog.asserts.assert(quote === ol.expression.Char.SINGLE_QUOTE || goog.asserts.assert(quote === ol.expr.Char.SINGLE_QUOTE ||
quote === ol.expression.Char.DOUBLE_QUOTE, quote === ol.expr.Char.DOUBLE_QUOTE,
'Strings must start with a quote: ' + String.fromCharCode(quote)); 'Strings must start with a quote: ' + String.fromCharCode(quote));
var start = this.index_; var start = this.index_;
@@ -825,7 +825,7 @@ ol.expression.Lexer.prototype.scanStringLiteral_ = function(quote) {
break; break;
} }
// look for escaped quote or backslash // look for escaped quote or backslash
if (code === ol.expression.Char.BACKSLASH) { if (code === ol.expr.Char.BACKSLASH) {
str += this.getCurrentChar_(); str += this.getCurrentChar_();
this.increment_(1); this.increment_(1);
} else { } else {
@@ -835,11 +835,11 @@ ol.expression.Lexer.prototype.scanStringLiteral_ = function(quote) {
if (quote !== 0) { if (quote !== 0) {
// unterminated string literal // unterminated string literal
throw new ol.expression.UnexpectedToken(this.peek()); throw new ol.expr.UnexpectedToken(this.peek());
} }
return { return {
type: ol.expression.TokenType.STRING_LITERAL, type: ol.expr.TokenType.STRING_LITERAL,
value: str, value: str,
index: start index: start
}; };
@@ -849,7 +849,7 @@ ol.expression.Lexer.prototype.scanStringLiteral_ = function(quote) {
/** /**
* After peeking, skip may be called to advance the cursor without re-scanning. * After peeking, skip may be called to advance the cursor without re-scanning.
*/ */
ol.expression.Lexer.prototype.skip = function() { ol.expr.Lexer.prototype.skip = function() {
this.index_ = this.nextIndex_; this.index_ = this.nextIndex_;
}; };
@@ -859,7 +859,7 @@ ol.expression.Lexer.prototype.skip = function() {
* @return {number} The character code of the first non-whitespace character. * @return {number} The character code of the first non-whitespace character.
* @private * @private
*/ */
ol.expression.Lexer.prototype.skipWhitespace_ = function() { ol.expr.Lexer.prototype.skipWhitespace_ = function() {
var code = NaN; var code = NaN;
while (this.index_ < this.length_) { while (this.index_ < this.length_) {
code = this.getCurrentCharCode_(); code = this.getCurrentCharCode_();
@@ -876,25 +876,25 @@ ol.expression.Lexer.prototype.skipWhitespace_ = function() {
/** /**
* Error object for unexpected tokens. * Error object for unexpected tokens.
* @param {ol.expression.Token} token The unexpected token. * @param {ol.expr.Token} token The unexpected token.
* @param {string=} opt_message Custom error message. * @param {string=} opt_message Custom error message.
* @constructor * @constructor
* @extends {goog.debug.Error} * @extends {goog.debug.Error}
*/ */
ol.expression.UnexpectedToken = function(token, opt_message) { ol.expr.UnexpectedToken = function(token, opt_message) {
var message = goog.isDef(opt_message) ? opt_message : var message = goog.isDef(opt_message) ? opt_message :
'Unexpected token ' + token.value + ' at index ' + token.index; 'Unexpected token ' + token.value + ' at index ' + token.index;
goog.debug.Error.call(this, message); goog.debug.Error.call(this, message);
/** /**
* @type {ol.expression.Token} * @type {ol.expr.Token}
*/ */
this.token = token; this.token = token;
}; };
goog.inherits(ol.expression.UnexpectedToken, goog.debug.Error); goog.inherits(ol.expr.UnexpectedToken, goog.debug.Error);
/** @override */ /** @override */
ol.expression.UnexpectedToken.prototype.name = 'UnexpectedToken'; ol.expr.UnexpectedToken.prototype.name = 'UnexpectedToken';

234
src/ol/expression/parser.js → src/ol/expr/parser.js
View File

@@ -13,31 +13,31 @@
* Copyright (C) 2011 Ariya Hidayat <ariya.hidayat@gmail.com> * Copyright (C) 2011 Ariya Hidayat <ariya.hidayat@gmail.com>
*/ */
goog.provide('ol.expression.Parser'); goog.provide('ol.expr.Parser');
goog.require('goog.asserts'); goog.require('goog.asserts');
goog.require('ol.expression.Call'); goog.require('ol.expr.Call');
goog.require('ol.expression.Comparison'); goog.require('ol.expr.Comparison');
goog.require('ol.expression.ComparisonOp'); goog.require('ol.expr.ComparisonOp');
goog.require('ol.expression.Expression'); goog.require('ol.expr.Expression');
goog.require('ol.expression.Identifier'); goog.require('ol.expr.Identifier');
goog.require('ol.expression.Lexer'); goog.require('ol.expr.Lexer');
goog.require('ol.expression.Literal'); goog.require('ol.expr.Literal');
goog.require('ol.expression.Logical'); goog.require('ol.expr.Logical');
goog.require('ol.expression.LogicalOp'); goog.require('ol.expr.LogicalOp');
goog.require('ol.expression.Math'); goog.require('ol.expr.Math');
goog.require('ol.expression.MathOp'); goog.require('ol.expr.MathOp');
goog.require('ol.expression.Member'); goog.require('ol.expr.Member');
goog.require('ol.expression.Not'); goog.require('ol.expr.Not');
goog.require('ol.expression.Token'); goog.require('ol.expr.Token');
goog.require('ol.expression.TokenType'); goog.require('ol.expr.TokenType');
goog.require('ol.expression.UnexpectedToken'); goog.require('ol.expr.UnexpectedToken');
/** /**
* Instances of ol.expression.Parser parse a very limited set of ECMAScript * Instances of ol.expr.Parser parse a very limited set of ECMAScript
* expressions (http://www.ecma-international.org/ecma-262/5.1/#sec-11). * expressions (http://www.ecma-international.org/ecma-262/5.1/#sec-11).
* *
* - Primary Expression (11.1): * - Primary Expression (11.1):
@@ -60,50 +60,50 @@ goog.require('ol.expression.UnexpectedToken');
* *
* @constructor * @constructor
*/ */
ol.expression.Parser = function() { ol.expr.Parser = function() {
}; };
/** /**
* Determine the precedence for the given token. * Determine the precedence for the given token.
* *
* @param {ol.expression.Token} token A token. * @param {ol.expr.Token} token A token.
* @return {number} The precedence for the given token. Higher gets more * @return {number} The precedence for the given token. Higher gets more
* precedence. * precedence.
* @private * @private
*/ */
ol.expression.Parser.prototype.binaryPrecedence_ = function(token) { ol.expr.Parser.prototype.binaryPrecedence_ = function(token) {
var precedence = 0; var precedence = 0;
if (token.type !== ol.expression.TokenType.PUNCTUATOR) { if (token.type !== ol.expr.TokenType.PUNCTUATOR) {
return precedence; return precedence;
} }
switch (token.value) { switch (token.value) {
case ol.expression.LogicalOp.OR: case ol.expr.LogicalOp.OR:
precedence = 1; precedence = 1;
break; break;
case ol.expression.LogicalOp.AND: case ol.expr.LogicalOp.AND:
precedence = 2; precedence = 2;
break; break;
case ol.expression.ComparisonOp.EQ: case ol.expr.ComparisonOp.EQ:
case ol.expression.ComparisonOp.NEQ: case ol.expr.ComparisonOp.NEQ:
case ol.expression.ComparisonOp.STRICT_EQ: case ol.expr.ComparisonOp.STRICT_EQ:
case ol.expression.ComparisonOp.STRICT_NEQ: case ol.expr.ComparisonOp.STRICT_NEQ:
precedence = 3; precedence = 3;
break; break;
case ol.expression.ComparisonOp.GT: case ol.expr.ComparisonOp.GT:
case ol.expression.ComparisonOp.LT: case ol.expr.ComparisonOp.LT:
case ol.expression.ComparisonOp.GTE: case ol.expr.ComparisonOp.GTE:
case ol.expression.ComparisonOp.LTE: case ol.expr.ComparisonOp.LTE:
precedence = 4; precedence = 4;
break; break;
case ol.expression.MathOp.ADD: case ol.expr.MathOp.ADD:
case ol.expression.MathOp.SUBTRACT: case ol.expr.MathOp.SUBTRACT:
precedence = 5; precedence = 5;
break; break;
case ol.expression.MathOp.MULTIPLY: case ol.expr.MathOp.MULTIPLY:
case ol.expression.MathOp.DIVIDE: case ol.expr.MathOp.DIVIDE:
case ol.expression.MathOp.MOD: case ol.expr.MathOp.MOD:
precedence = 6; precedence = 6;
break; break;
default: default:
@@ -119,25 +119,25 @@ ol.expression.Parser.prototype.binaryPrecedence_ = function(token) {
* Create a binary expression. * Create a binary expression.
* *
* @param {string} operator Operator. * @param {string} operator Operator.
* @param {ol.expression.Expression} left Left expression. * @param {ol.expr.Expression} left Left expression.
* @param {ol.expression.Expression} right Right expression. * @param {ol.expr.Expression} right Right expression.
* @return {ol.expression.Expression} The expression. * @return {ol.expr.Expression} The expression.
* @private * @private
*/ */
ol.expression.Parser.prototype.createBinaryExpression_ = function(operator, ol.expr.Parser.prototype.createBinaryExpression_ = function(operator,
left, right) { left, right) {
var expr; var expr;
if (ol.expression.Comparison.isValidOp(operator)) { if (ol.expr.Comparison.isValidOp(operator)) {
expr = new ol.expression.Comparison( expr = new ol.expr.Comparison(
/** @type {ol.expression.ComparisonOp.<string>} */ (operator), /** @type {ol.expr.ComparisonOp.<string>} */ (operator),
left, right); left, right);
} else if (ol.expression.Logical.isValidOp(operator)) { } else if (ol.expr.Logical.isValidOp(operator)) {
expr = new ol.expression.Logical( expr = new ol.expr.Logical(
/** @type {ol.expression.LogicalOp.<string>} */ (operator), /** @type {ol.expr.LogicalOp.<string>} */ (operator),
left, right); left, right);
} else if (ol.expression.Math.isValidOp(operator)) { } else if (ol.expr.Math.isValidOp(operator)) {
expr = new ol.expression.Math( expr = new ol.expr.Math(
/** @type {ol.expression.MathOp.<string>} */ (operator), /** @type {ol.expr.MathOp.<string>} */ (operator),
left, right); left, right);
} else { } else {
throw new Error('Unsupported binary operator: ' + operator); throw new Error('Unsupported binary operator: ' + operator);
@@ -149,13 +149,13 @@ ol.expression.Parser.prototype.createBinaryExpression_ = function(operator,
/** /**
* Create a call expression. * Create a call expression.
* *
* @param {ol.expression.Expression} callee Expression for function. * @param {ol.expr.Expression} callee Expression for function.
* @param {Array.<ol.expression.Expression>} args Arguments array. * @param {Array.<ol.expr.Expression>} args Arguments array.
* @return {ol.expression.Call} Call expression. * @return {ol.expr.Call} Call expression.
* @private * @private
*/ */
ol.expression.Parser.prototype.createCallExpression_ = function(callee, args) { ol.expr.Parser.prototype.createCallExpression_ = function(callee, args) {
return new ol.expression.Call(callee, args); return new ol.expr.Call(callee, args);
}; };
@@ -163,11 +163,11 @@ ol.expression.Parser.prototype.createCallExpression_ = function(callee, args) {
* Create an identifier expression. * Create an identifier expression.
* *
* @param {string} name Identifier name. * @param {string} name Identifier name.
* @return {ol.expression.Identifier} Identifier expression. * @return {ol.expr.Identifier} Identifier expression.
* @private * @private
*/ */
ol.expression.Parser.prototype.createIdentifier_ = function(name) { ol.expr.Parser.prototype.createIdentifier_ = function(name) {
return new ol.expression.Identifier(name); return new ol.expr.Identifier(name);
}; };
@@ -175,26 +175,26 @@ ol.expression.Parser.prototype.createIdentifier_ = function(name) {
* Create a literal expression. * Create a literal expression.
* *
* @param {string|number|boolean|null} value Literal value. * @param {string|number|boolean|null} value Literal value.
* @return {ol.expression.Literal} The literal expression. * @return {ol.expr.Literal} The literal expression.
* @private * @private
*/ */
ol.expression.Parser.prototype.createLiteral_ = function(value) { ol.expr.Parser.prototype.createLiteral_ = function(value) {
return new ol.expression.Literal(value); return new ol.expr.Literal(value);
}; };
/** /**
* Create a member expression. * Create a member expression.
* *
* // TODO: make exp {ol.expression.Member|ol.expression.Identifier} * // TODO: make exp {ol.expr.Member|ol.expr.Identifier}
* @param {ol.expression.Expression} object Expression. * @param {ol.expr.Expression} object Expression.
* @param {ol.expression.Identifier} property Member name. * @param {ol.expr.Identifier} property Member name.
* @return {ol.expression.Member} The member expression. * @return {ol.expr.Member} The member expression.
* @private * @private
*/ */
ol.expression.Parser.prototype.createMemberExpression_ = function(object, ol.expr.Parser.prototype.createMemberExpression_ = function(object,
property) { property) {
return new ol.expression.Member(object, property); return new ol.expr.Member(object, property);
}; };
@@ -203,18 +203,18 @@ ol.expression.Parser.prototype.createMemberExpression_ = function(object,
* "!". For +/-, we apply the operator to literal expressions and return * "!". For +/-, we apply the operator to literal expressions and return
* another literal. * another literal.
* *
* @param {ol.expression.Token} op Operator. * @param {ol.expr.Token} op Operator.
* @param {ol.expression.Expression} argument Expression. * @param {ol.expr.Expression} argument Expression.
* @return {ol.expression.Expression} The unary expression. * @return {ol.expr.Expression} The unary expression.
* @private * @private
*/ */
ol.expression.Parser.prototype.createUnaryExpression_ = function(op, argument) { ol.expr.Parser.prototype.createUnaryExpression_ = function(op, argument) {
goog.asserts.assert(op.value === '!' || op.value === '+' || op.value === '-'); goog.asserts.assert(op.value === '!' || op.value === '+' || op.value === '-');
var expr; var expr;
if (op.value === '!') { if (op.value === '!') {
expr = new ol.expression.Not(argument); expr = new ol.expr.Not(argument);
} else if (!(argument instanceof ol.expression.Literal)) { } else if (!(argument instanceof ol.expr.Literal)) {
throw new ol.expression.UnexpectedToken(op); throw new ol.expr.UnexpectedToken(op);
} else { } else {
// we've got +/- literal // we've got +/- literal
if (op.value === '+') { if (op.value === '+') {
@@ -233,14 +233,14 @@ ol.expression.Parser.prototype.createUnaryExpression_ = function(op, argument) {
* Parse an expression. * Parse an expression.
* *
* @param {string} source Expression source. * @param {string} source Expression source.
* @return {ol.expression.Expression} Expression. * @return {ol.expr.Expression} Expression.
*/ */
ol.expression.Parser.prototype.parse = function(source) { ol.expr.Parser.prototype.parse = function(source) {
var lexer = new ol.expression.Lexer(source); var lexer = new ol.expr.Lexer(source);
var expr = this.parseExpression_(lexer); var expr = this.parseExpression_(lexer);
var token = lexer.peek(); var token = lexer.peek();
if (token.type !== ol.expression.TokenType.EOF) { if (token.type !== ol.expr.TokenType.EOF) {
throw new ol.expression.UnexpectedToken(token); throw new ol.expr.UnexpectedToken(token);
} }
return expr; return expr;
}; };
@@ -250,11 +250,11 @@ ol.expression.Parser.prototype.parse = function(source) {
* Parse call arguments * Parse call arguments
* http://www.ecma-international.org/ecma-262/5.1/#sec-11.2.4 * http://www.ecma-international.org/ecma-262/5.1/#sec-11.2.4
* *
* @param {ol.expression.Lexer} lexer Lexer. * @param {ol.expr.Lexer} lexer Lexer.
* @return {Array.<ol.expression.Expression>} Arguments. * @return {Array.<ol.expr.Expression>} Arguments.
* @private * @private
*/ */
ol.expression.Parser.prototype.parseArguments_ = function(lexer) { ol.expr.Parser.prototype.parseArguments_ = function(lexer) {
var args = []; var args = [];
lexer.expect('('); lexer.expect('(');
@@ -292,11 +292,11 @@ ol.expression.Parser.prototype.parseArguments_ = function(lexer) {
* - Binary Logical Operators (`&&`, `||`) * - Binary Logical Operators (`&&`, `||`)
* http://www.ecma-international.org/ecma-262/5.1/#sec-11.11 * http://www.ecma-international.org/ecma-262/5.1/#sec-11.11
* *
* @param {ol.expression.Lexer} lexer Lexer. * @param {ol.expr.Lexer} lexer Lexer.
* @return {ol.expression.Expression} Expression. * @return {ol.expr.Expression} Expression.
* @private * @private
*/ */
ol.expression.Parser.prototype.parseBinaryExpression_ = function(lexer) { ol.expr.Parser.prototype.parseBinaryExpression_ = function(lexer) {
var left = this.parseUnaryExpression_(lexer); var left = this.parseUnaryExpression_(lexer);
var operator = lexer.peek(); var operator = lexer.peek();
@@ -343,11 +343,11 @@ ol.expression.Parser.prototype.parseBinaryExpression_ = function(lexer) {
* Parse a group expression. * Parse a group expression.
* http://www.ecma-international.org/ecma-262/5.1/#sec-11.1.6 * http://www.ecma-international.org/ecma-262/5.1/#sec-11.1.6
* *
* @param {ol.expression.Lexer} lexer Lexer. * @param {ol.expr.Lexer} lexer Lexer.
* @return {ol.expression.Expression} Expression. * @return {ol.expr.Expression} Expression.
* @private * @private
*/ */
ol.expression.Parser.prototype.parseGroupExpression_ = function(lexer) { ol.expr.Parser.prototype.parseGroupExpression_ = function(lexer) {
lexer.expect('('); lexer.expect('(');
var expr = this.parseExpression_(lexer); var expr = this.parseExpression_(lexer);
lexer.expect(')'); lexer.expect(')');
@@ -360,18 +360,18 @@ ol.expression.Parser.prototype.parseGroupExpression_ = function(lexer) {
* and Call Expressions. * and Call Expressions.
* http://www.ecma-international.org/ecma-262/5.1/#sec-11.2 * http://www.ecma-international.org/ecma-262/5.1/#sec-11.2
* *
* @param {ol.expression.Lexer} lexer Lexer. * @param {ol.expr.Lexer} lexer Lexer.
* @return {ol.expression.Expression} Expression. * @return {ol.expr.Expression} Expression.
* @private * @private
*/ */
ol.expression.Parser.prototype.parseLeftHandSideExpression_ = function(lexer) { ol.expr.Parser.prototype.parseLeftHandSideExpression_ = function(lexer) {
var expr = this.parsePrimaryExpression_(lexer); var expr = this.parsePrimaryExpression_(lexer);
var token = lexer.peek(); var token = lexer.peek();
if (token.value === '(') { if (token.value === '(') {
// only allow calls on identifiers (e.g. `foo()` not `foo.bar()`) // only allow calls on identifiers (e.g. `foo()` not `foo.bar()`)
if (!(expr instanceof ol.expression.Identifier)) { if (!(expr instanceof ol.expr.Identifier)) {
// TODO: more helpful error messages for restricted syntax // TODO: more helpful error messages for restricted syntax
throw new ol.expression.UnexpectedToken(token); throw new ol.expr.UnexpectedToken(token);
} }
var args = this.parseArguments_(lexer); var args = this.parseArguments_(lexer);
expr = this.createCallExpression_(expr, args); expr = this.createCallExpression_(expr, args);
@@ -391,19 +391,19 @@ ol.expression.Parser.prototype.parseLeftHandSideExpression_ = function(lexer) {
* Parse non-computed member. * Parse non-computed member.
* http://www.ecma-international.org/ecma-262/5.1/#sec-11.2 * http://www.ecma-international.org/ecma-262/5.1/#sec-11.2
* *
* @param {ol.expression.Lexer} lexer Lexer. * @param {ol.expr.Lexer} lexer Lexer.
* @return {ol.expression.Identifier} Expression. * @return {ol.expr.Identifier} Expression.
* @private * @private
*/ */
ol.expression.Parser.prototype.parseNonComputedMember_ = function(lexer) { ol.expr.Parser.prototype.parseNonComputedMember_ = function(lexer) {
lexer.expect('.'); lexer.expect('.');
var token = lexer.next(); var token = lexer.next();
if (token.type !== ol.expression.TokenType.IDENTIFIER && if (token.type !== ol.expr.TokenType.IDENTIFIER &&
token.type !== ol.expression.TokenType.KEYWORD && token.type !== ol.expr.TokenType.KEYWORD &&
token.type !== ol.expression.TokenType.BOOLEAN_LITERAL && token.type !== ol.expr.TokenType.BOOLEAN_LITERAL &&
token.type !== ol.expression.TokenType.NULL_LITERAL) { token.type !== ol.expr.TokenType.NULL_LITERAL) {
throw new ol.expression.UnexpectedToken(token); throw new ol.expr.UnexpectedToken(token);
} }
return this.createIdentifier_(String(token.value)); return this.createIdentifier_(String(token.value));
@@ -414,11 +414,11 @@ ol.expression.Parser.prototype.parseNonComputedMember_ = function(lexer) {
* Parse primary expression. * Parse primary expression.
* http://www.ecma-international.org/ecma-262/5.1/#sec-11.1 * http://www.ecma-international.org/ecma-262/5.1/#sec-11.1
* *
* @param {ol.expression.Lexer} lexer Lexer. * @param {ol.expr.Lexer} lexer Lexer.
* @return {ol.expression.Expression} Expression. * @return {ol.expr.Expression} Expression.
* @private * @private
*/ */
ol.expression.Parser.prototype.parsePrimaryExpression_ = function(lexer) { ol.expr.Parser.prototype.parsePrimaryExpression_ = function(lexer) {
var token = lexer.peek(); var token = lexer.peek();
if (token.value === '(') { if (token.value === '(') {
return this.parseGroupExpression_(lexer); return this.parseGroupExpression_(lexer);
@@ -426,19 +426,19 @@ ol.expression.Parser.prototype.parsePrimaryExpression_ = function(lexer) {
lexer.skip(); lexer.skip();
var expr; var expr;
var type = token.type; var type = token.type;
if (type === ol.expression.TokenType.IDENTIFIER) { if (type === ol.expr.TokenType.IDENTIFIER) {
expr = this.createIdentifier_(/** @type {string} */ (token.value)); expr = this.createIdentifier_(/** @type {string} */ (token.value));
} else if (type === ol.expression.TokenType.STRING_LITERAL || } else if (type === ol.expr.TokenType.STRING_LITERAL ||
type === ol.expression.TokenType.NUMERIC_LITERAL) { type === ol.expr.TokenType.NUMERIC_LITERAL) {
// numeric and string literals are already the correct type // numeric and string literals are already the correct type
expr = this.createLiteral_(token.value); expr = this.createLiteral_(token.value);
} else if (type === ol.expression.TokenType.BOOLEAN_LITERAL) { } else if (type === ol.expr.TokenType.BOOLEAN_LITERAL) {
// because booleans are valid member properties, tokens are still string // because booleans are valid member properties, tokens are still string
expr = this.createLiteral_(token.value === 'true'); expr = this.createLiteral_(token.value === 'true');
} else if (type === ol.expression.TokenType.NULL_LITERAL) { } else if (type === ol.expr.TokenType.NULL_LITERAL) {
expr = this.createLiteral_(null); expr = this.createLiteral_(null);
} else { } else {
throw new ol.expression.UnexpectedToken(token); throw new ol.expr.UnexpectedToken(token);
} }
return expr; return expr;
}; };
@@ -448,14 +448,14 @@ ol.expression.Parser.prototype.parsePrimaryExpression_ = function(lexer) {
* Parse expression with a unary operator. Limited to logical not operator. * Parse expression with a unary operator. Limited to logical not operator.
* http://www.ecma-international.org/ecma-262/5.1/#sec-11.4 * http://www.ecma-international.org/ecma-262/5.1/#sec-11.4
* *
* @param {ol.expression.Lexer} lexer Lexer. * @param {ol.expr.Lexer} lexer Lexer.
* @return {ol.expression.Expression} Expression. * @return {ol.expr.Expression} Expression.
* @private * @private
*/ */
ol.expression.Parser.prototype.parseUnaryExpression_ = function(lexer) { ol.expr.Parser.prototype.parseUnaryExpression_ = function(lexer) {
var expr; var expr;
var operator = lexer.peek(); var operator = lexer.peek();
if (operator.type !== ol.expression.TokenType.PUNCTUATOR) { if (operator.type !== ol.expr.TokenType.PUNCTUATOR) {
expr = this.parseLeftHandSideExpression_(lexer); expr = this.parseLeftHandSideExpression_(lexer);
} else if (operator.value === '!' || operator.value === '-' || } else if (operator.value === '!' || operator.value === '-' ||
operator.value === '+') { operator.value === '+') {
@@ -472,10 +472,10 @@ ol.expression.Parser.prototype.parseUnaryExpression_ = function(lexer) {
/** /**
* Parse an expression. * Parse an expression.
* *
* @param {ol.expression.Lexer} lexer Lexer. * @param {ol.expr.Lexer} lexer Lexer.
* @return {ol.expression.Expression} Expression. * @return {ol.expr.Expression} Expression.
* @private * @private
*/ */
ol.expression.Parser.prototype.parseExpression_ = function(lexer) { ol.expr.Parser.prototype.parseExpression_ = function(lexer) {
return this.parseBinaryExpression_(lexer); return this.parseBinaryExpression_(lexer);
}; };

3
src/ol/expression.jsdoc
View File

@@ -1,3 +0,0 @@
/**
* @namespace ol.expression
*/

2
src/ol/expression/expression.exports
View File

@@ -1,2 +0,0 @@
@exportSymbol ol.expression.parse
@exportSymbol ol.expression.register

50
src/ol/layer/vectorlayer.js
View File

@@ -5,10 +5,10 @@ goog.require('goog.asserts');
goog.require('goog.events.EventType'); goog.require('goog.events.EventType');
goog.require('goog.object'); goog.require('goog.object');
goog.require('ol.Feature'); goog.require('ol.Feature');
goog.require('ol.expression'); goog.require('ol.expr');
goog.require('ol.expression.Literal'); goog.require('ol.expr.Literal');
goog.require('ol.expression.Logical'); goog.require('ol.expr.Logical');
goog.require('ol.expression.LogicalOp'); goog.require('ol.expr.LogicalOp');
goog.require('ol.geom.GeometryType'); goog.require('ol.geom.GeometryType');
goog.require('ol.geom.SharedVertices'); goog.require('ol.geom.SharedVertices');
goog.require('ol.layer.Layer'); goog.require('ol.layer.Layer');
@@ -83,7 +83,7 @@ ol.layer.FeatureCache.prototype.add = function(feature) {
/** /**
* @param {ol.expression.Expression=} opt_expr Expression for filtering. * @param {ol.expr.Expression=} opt_expr Expression for filtering.
* @return {Object.<string, ol.Feature>} Object of features, keyed by id. * @return {Object.<string, ol.Feature>} Object of features, keyed by id.
*/ */
ol.layer.FeatureCache.prototype.getFeaturesObject = function(opt_expr) { ol.layer.FeatureCache.prototype.getFeaturesObject = function(opt_expr) {
@@ -92,48 +92,48 @@ ol.layer.FeatureCache.prototype.getFeaturesObject = function(opt_expr) {
features = this.idLookup_; features = this.idLookup_;
} else { } else {
// check for geometryType or extent expression // check for geometryType or extent expression
var name = ol.expression.isLibCall(opt_expr); var name = ol.expr.isLibCall(opt_expr);
if (name === 'geometryType') { if (name === 'geometryType') {
var args = /** @type {ol.expression.Call} */ (opt_expr).getArgs(); var args = /** @type {ol.expr.Call} */ (opt_expr).getArgs();
goog.asserts.assert(args.length === 1); goog.asserts.assert(args.length === 1);
goog.asserts.assert(args[0] instanceof ol.expression.Literal); goog.asserts.assert(args[0] instanceof ol.expr.Literal);
var type = /** @type {ol.expression.Literal } */ (args[0]).evaluate(); var type = /** @type {ol.expr.Literal } */ (args[0]).evaluate();
goog.asserts.assertString(type); goog.asserts.assertString(type);
features = this.geometryTypeIndex_[type]; features = this.geometryTypeIndex_[type];
} else if (name === 'extent') { } else if (name === 'extent') {
var args = /** @type {ol.expression.Call} */ (opt_expr).getArgs(); var args = /** @type {ol.expr.Call} */ (opt_expr).getArgs();
goog.asserts.assert(args.length === 4); goog.asserts.assert(args.length === 4);
var extent = []; var extent = [];
for (var i = 0; i < 4; ++i) { for (var i = 0; i < 4; ++i) {
goog.asserts.assert(args[i] instanceof ol.expression.Literal); goog.asserts.assert(args[i] instanceof ol.expr.Literal);
extent[i] = /** @type {ol.expression.Literal} */ (args[i]).evaluate(); extent[i] = /** @type {ol.expr.Literal} */ (args[i]).evaluate();
goog.asserts.assertNumber(extent[i]); goog.asserts.assertNumber(extent[i]);
} }
features = this.rTree_.searchReturningObject(extent); features = this.rTree_.searchReturningObject(extent);
} else { } else {
// not a call expression, check logical // not a call expression, check logical
if (opt_expr instanceof ol.expression.Logical) { if (opt_expr instanceof ol.expr.Logical) {
var op = /** @type {ol.expression.Logical} */ (opt_expr).getOperator(); var op = /** @type {ol.expr.Logical} */ (opt_expr).getOperator();
if (op === ol.expression.LogicalOp.AND) { if (op === ol.expr.LogicalOp.AND) {
var expressions = [opt_expr.getLeft(), opt_expr.getRight()]; var expressions = [opt_expr.getLeft(), opt_expr.getRight()];
var expr, args, type, extent; var expr, args, type, extent;
for (var i = 0; i <= 1; ++i) { for (var i = 0; i <= 1; ++i) {
expr = expressions[i]; expr = expressions[i];
name = ol.expression.isLibCall(expr); name = ol.expr.isLibCall(expr);
if (name === 'geometryType') { if (name === 'geometryType') {
args = /** @type {ol.expression.Call} */ (expr).getArgs(); args = /** @type {ol.expr.Call} */ (expr).getArgs();
goog.asserts.assert(args.length === 1); goog.asserts.assert(args.length === 1);
goog.asserts.assert(args[0] instanceof ol.expression.Literal); goog.asserts.assert(args[0] instanceof ol.expr.Literal);
type = /** @type {ol.expression.Literal } */ (args[0]).evaluate(); type = /** @type {ol.expr.Literal } */ (args[0]).evaluate();
goog.asserts.assertString(type); goog.asserts.assertString(type);
} else if (name === 'extent') { } else if (name === 'extent') {
args = /** @type {ol.expression.Call} */ (expr).getArgs(); args = /** @type {ol.expr.Call} */ (expr).getArgs();
goog.asserts.assert(args.length === 4); goog.asserts.assert(args.length === 4);
extent = []; extent = [];
for (var j = 0; j < 4; ++j) { for (var j = 0; j < 4; ++j) {
goog.asserts.assert(args[j] instanceof ol.expression.Literal); goog.asserts.assert(args[j] instanceof ol.expr.Literal);
extent[j] = extent[j] =
/** @type {ol.expression.Literal} */ (args[j]).evaluate(); /** @type {ol.expr.Literal} */ (args[j]).evaluate();
goog.asserts.assertNumber(extent[j]); goog.asserts.assertNumber(extent[j]);
} }
} }
@@ -152,7 +152,7 @@ ol.layer.FeatureCache.prototype.getFeaturesObject = function(opt_expr) {
features = {}; features = {};
for (i in candidates) { for (i in candidates) {
feature = candidates[i]; feature = candidates[i];
if (ol.expression.evaluateFeature(opt_expr, feature)) { if (ol.expr.evaluateFeature(opt_expr, feature)) {
features[i] = feature; features[i] = feature;
} }
} }
@@ -278,7 +278,7 @@ ol.layer.Vector.prototype.getVectorSource = function() {
/** /**
* @param {ol.expression.Expression=} opt_expr Expression for filtering. * @param {ol.expr.Expression=} opt_expr Expression for filtering.
* @return {Array.<ol.Feature>} Array of features. * @return {Array.<ol.Feature>} Array of features.
*/ */
ol.layer.Vector.prototype.getFeatures = function(opt_expr) { ol.layer.Vector.prototype.getFeatures = function(opt_expr) {
@@ -288,7 +288,7 @@ ol.layer.Vector.prototype.getFeatures = function(opt_expr) {
/** /**
* @param {ol.expression.Expression=} opt_expr Expression for filtering. * @param {ol.expr.Expression=} opt_expr Expression for filtering.
* @return {Object.<string, ol.Feature>} Features. * @return {Object.<string, ol.Feature>} Features.
*/ */
ol.layer.Vector.prototype.getFeaturesObject = function(opt_expr) { ol.layer.Vector.prototype.getFeaturesObject = function(opt_expr) {

50
src/ol/style/icon.js
View File

@@ -3,9 +3,9 @@ goog.provide('ol.style.IconLiteral');
goog.provide('ol.style.IconType'); goog.provide('ol.style.IconType');
goog.require('goog.asserts'); goog.require('goog.asserts');
goog.require('ol.expression'); goog.require('ol.expr');
goog.require('ol.expression.Expression'); goog.require('ol.expr.Expression');
goog.require('ol.expression.Literal'); goog.require('ol.expr.Literal');
goog.require('ol.style.Point'); goog.require('ol.style.Point');
goog.require('ol.style.PointLiteral'); goog.require('ol.style.PointLiteral');
@@ -70,47 +70,47 @@ ol.style.Icon = function(options) {
goog.asserts.assert(options.url, 'url must be set'); goog.asserts.assert(options.url, 'url must be set');
/** /**
* @type {ol.expression.Expression} * @type {ol.expr.Expression}
* @private * @private
*/ */
this.url_ = (options.url instanceof ol.expression.Expression) ? this.url_ = (options.url instanceof ol.expr.Expression) ?
options.url : new ol.expression.Literal(options.url); options.url : new ol.expr.Literal(options.url);
/** /**
* @type {ol.expression.Expression} * @type {ol.expr.Expression}
* @private * @private
*/ */
this.width_ = !goog.isDef(options.width) ? this.width_ = !goog.isDef(options.width) ?
null : null :
(options.width instanceof ol.expression.Expression) ? (options.width instanceof ol.expr.Expression) ?
options.width : new ol.expression.Literal(options.width); options.width : new ol.expr.Literal(options.width);
/** /**
* @type {ol.expression.Expression} * @type {ol.expr.Expression}
* @private * @private
*/ */
this.height_ = !goog.isDef(options.height) ? this.height_ = !goog.isDef(options.height) ?
null : null :
(options.height instanceof ol.expression.Expression) ? (options.height instanceof ol.expr.Expression) ?
options.height : new ol.expression.Literal(options.height); options.height : new ol.expr.Literal(options.height);
/** /**
* @type {ol.expression.Expression} * @type {ol.expr.Expression}
* @private * @private
*/ */
this.opacity_ = !goog.isDef(options.opacity) ? this.opacity_ = !goog.isDef(options.opacity) ?
new ol.expression.Literal(ol.style.IconDefaults.opacity) : new ol.expr.Literal(ol.style.IconDefaults.opacity) :
(options.opacity instanceof ol.expression.Expression) ? (options.opacity instanceof ol.expr.Expression) ?
options.opacity : new ol.expression.Literal(options.opacity); options.opacity : new ol.expr.Literal(options.opacity);
/** /**
* @type {ol.expression.Expression} * @type {ol.expr.Expression}
* @private * @private
*/ */
this.rotation_ = !goog.isDef(options.rotation) ? this.rotation_ = !goog.isDef(options.rotation) ?
new ol.expression.Literal(ol.style.IconDefaults.rotation) : new ol.expr.Literal(ol.style.IconDefaults.rotation) :
(options.rotation instanceof ol.expression.Expression) ? (options.rotation instanceof ol.expr.Expression) ?
options.rotation : new ol.expression.Literal(options.rotation); options.rotation : new ol.expr.Literal(options.rotation);
}; };
@@ -121,26 +121,26 @@ ol.style.Icon = function(options) {
*/ */
ol.style.Icon.prototype.createLiteral = function(opt_feature) { ol.style.Icon.prototype.createLiteral = function(opt_feature) {
var url = ol.expression.evaluateFeature(this.url_, opt_feature); var url = ol.expr.evaluateFeature(this.url_, opt_feature);
goog.asserts.assertString(url, 'url must be a string'); goog.asserts.assertString(url, 'url must be a string');
goog.asserts.assert(url != '#', 'url must not be "#"'); goog.asserts.assert(url != '#', 'url must not be "#"');
var width; var width;
if (!goog.isNull(this.width_)) { if (!goog.isNull(this.width_)) {
width = ol.expression.evaluateFeature(this.width_, opt_feature); width = ol.expr.evaluateFeature(this.width_, opt_feature);
goog.asserts.assertNumber(width, 'width must be a number'); goog.asserts.assertNumber(width, 'width must be a number');
} }
var height; var height;
if (!goog.isNull(this.height_)) { if (!goog.isNull(this.height_)) {
height = ol.expression.evaluateFeature(this.height_, opt_feature); height = ol.expr.evaluateFeature(this.height_, opt_feature);
goog.asserts.assertNumber(height, 'height must be a number'); goog.asserts.assertNumber(height, 'height must be a number');
} }
var opacity = ol.expression.evaluateFeature(this.opacity_, opt_feature); var opacity = ol.expr.evaluateFeature(this.opacity_, opt_feature);
goog.asserts.assertNumber(opacity, 'opacity must be a number'); goog.asserts.assertNumber(opacity, 'opacity must be a number');
var rotation = ol.expression.evaluateFeature(this.rotation_, opt_feature); var rotation = ol.expr.evaluateFeature(this.rotation_, opt_feature);
goog.asserts.assertNumber(rotation, 'rotation must be a number'); goog.asserts.assertNumber(rotation, 'rotation must be a number');
return new ol.style.IconLiteral({ return new ol.style.IconLiteral({

36
src/ol/style/line.js
View File

@@ -2,9 +2,9 @@ goog.provide('ol.style.Line');
goog.provide('ol.style.LineLiteral'); goog.provide('ol.style.LineLiteral');
goog.require('goog.asserts'); goog.require('goog.asserts');
goog.require('ol.expression'); goog.require('ol.expr');
goog.require('ol.expression.Expression'); goog.require('ol.expr.Expression');
goog.require('ol.expression.Literal'); goog.require('ol.expr.Literal');
goog.require('ol.style.Symbolizer'); goog.require('ol.style.Symbolizer');
goog.require('ol.style.SymbolizerLiteral'); goog.require('ol.style.SymbolizerLiteral');
@@ -64,31 +64,31 @@ ol.style.Line = function(options) {
goog.base(this); goog.base(this);
/** /**
* @type {ol.expression.Expression} * @type {ol.expr.Expression}
* @private * @private
*/ */
this.strokeColor_ = !goog.isDef(options.strokeColor) ? this.strokeColor_ = !goog.isDef(options.strokeColor) ?
new ol.expression.Literal(ol.style.LineDefaults.strokeColor) : new ol.expr.Literal(ol.style.LineDefaults.strokeColor) :
(options.strokeColor instanceof ol.expression.Expression) ? (options.strokeColor instanceof ol.expr.Expression) ?
options.strokeColor : new ol.expression.Literal(options.strokeColor); options.strokeColor : new ol.expr.Literal(options.strokeColor);
/** /**
* @type {ol.expression.Expression} * @type {ol.expr.Expression}
* @private * @private
*/ */
this.strokeWidth_ = !goog.isDef(options.strokeWidth) ? this.strokeWidth_ = !goog.isDef(options.strokeWidth) ?
new ol.expression.Literal(ol.style.LineDefaults.strokeWidth) : new ol.expr.Literal(ol.style.LineDefaults.strokeWidth) :
(options.strokeWidth instanceof ol.expression.Expression) ? (options.strokeWidth instanceof ol.expr.Expression) ?
options.strokeWidth : new ol.expression.Literal(options.strokeWidth); options.strokeWidth : new ol.expr.Literal(options.strokeWidth);
/** /**
* @type {ol.expression.Expression} * @type {ol.expr.Expression}
* @private * @private
*/ */
this.opacity_ = !goog.isDef(options.opacity) ? this.opacity_ = !goog.isDef(options.opacity) ?
new ol.expression.Literal(ol.style.LineDefaults.opacity) : new ol.expr.Literal(ol.style.LineDefaults.opacity) :
(options.opacity instanceof ol.expression.Expression) ? (options.opacity instanceof ol.expr.Expression) ?
options.opacity : new ol.expression.Literal(options.opacity); options.opacity : new ol.expr.Literal(options.opacity);
}; };
goog.inherits(ol.style.Line, ol.style.Symbolizer); goog.inherits(ol.style.Line, ol.style.Symbolizer);
@@ -100,15 +100,15 @@ goog.inherits(ol.style.Line, ol.style.Symbolizer);
*/ */
ol.style.Line.prototype.createLiteral = function(opt_feature) { ol.style.Line.prototype.createLiteral = function(opt_feature) {
var strokeColor = ol.expression.evaluateFeature( var strokeColor = ol.expr.evaluateFeature(
this.strokeColor_, opt_feature); this.strokeColor_, opt_feature);
goog.asserts.assertString(strokeColor, 'strokeColor must be a string'); goog.asserts.assertString(strokeColor, 'strokeColor must be a string');
var strokeWidth = ol.expression.evaluateFeature( var strokeWidth = ol.expr.evaluateFeature(
this.strokeWidth_, opt_feature); this.strokeWidth_, opt_feature);
goog.asserts.assertNumber(strokeWidth, 'strokeWidth must be a number'); goog.asserts.assertNumber(strokeWidth, 'strokeWidth must be a number');
var opacity = ol.expression.evaluateFeature(this.opacity_, opt_feature); var opacity = ol.expr.evaluateFeature(this.opacity_, opt_feature);
goog.asserts.assertNumber(opacity, 'opacity must be a number'); goog.asserts.assertNumber(opacity, 'opacity must be a number');
return new ol.style.LineLiteral({ return new ol.style.LineLiteral({

44
src/ol/style/polygon.js
View File

@@ -2,9 +2,9 @@ goog.provide('ol.style.Polygon');
goog.provide('ol.style.PolygonLiteral'); goog.provide('ol.style.PolygonLiteral');
goog.require('goog.asserts'); goog.require('goog.asserts');
goog.require('ol.expression'); goog.require('ol.expr');
goog.require('ol.expression.Expression'); goog.require('ol.expr.Expression');
goog.require('ol.expression.Literal'); goog.require('ol.expr.Literal');
goog.require('ol.style.Symbolizer'); goog.require('ol.style.Symbolizer');
goog.require('ol.style.SymbolizerLiteral'); goog.require('ol.style.SymbolizerLiteral');
@@ -81,13 +81,13 @@ ol.style.Polygon = function(options) {
goog.base(this); goog.base(this);
/** /**
* @type {ol.expression.Expression} * @type {ol.expr.Expression}
* @private * @private
*/ */
this.fillColor_ = !goog.isDefAndNotNull(options.fillColor) ? this.fillColor_ = !goog.isDefAndNotNull(options.fillColor) ?
null : null :
(options.fillColor instanceof ol.expression.Expression) ? (options.fillColor instanceof ol.expr.Expression) ?
options.fillColor : new ol.expression.Literal(options.fillColor); options.fillColor : new ol.expr.Literal(options.fillColor);
// stroke handling - if any stroke property is supplied, use defaults // stroke handling - if any stroke property is supplied, use defaults
var strokeColor = null, var strokeColor = null,
@@ -97,32 +97,32 @@ ol.style.Polygon = function(options) {
goog.isDefAndNotNull(options.strokeWidth)) { goog.isDefAndNotNull(options.strokeWidth)) {
if (goog.isDefAndNotNull(options.strokeColor)) { if (goog.isDefAndNotNull(options.strokeColor)) {
strokeColor = (options.strokeColor instanceof ol.expression.Expression) ? strokeColor = (options.strokeColor instanceof ol.expr.Expression) ?
options.strokeColor : options.strokeColor :
new ol.expression.Literal(options.strokeColor); new ol.expr.Literal(options.strokeColor);
} else { } else {
strokeColor = new ol.expression.Literal( strokeColor = new ol.expr.Literal(
/** @type {string} */ (ol.style.PolygonDefaults.strokeColor)); /** @type {string} */ (ol.style.PolygonDefaults.strokeColor));
} }
if (goog.isDefAndNotNull(options.strokeWidth)) { if (goog.isDefAndNotNull(options.strokeWidth)) {
strokeWidth = (options.strokeWidth instanceof ol.expression.Expression) ? strokeWidth = (options.strokeWidth instanceof ol.expr.Expression) ?
options.strokeWidth : options.strokeWidth :
new ol.expression.Literal(options.strokeWidth); new ol.expr.Literal(options.strokeWidth);
} else { } else {
strokeWidth = new ol.expression.Literal( strokeWidth = new ol.expr.Literal(
/** @type {number} */ (ol.style.PolygonDefaults.strokeWidth)); /** @type {number} */ (ol.style.PolygonDefaults.strokeWidth));
} }
} }
/** /**
* @type {ol.expression.Expression} * @type {ol.expr.Expression}
* @private * @private
*/ */
this.strokeColor_ = strokeColor; this.strokeColor_ = strokeColor;
/** /**
* @type {ol.expression.Expression} * @type {ol.expr.Expression}
* @private * @private
*/ */
this.strokeWidth_ = strokeWidth; this.strokeWidth_ = strokeWidth;
@@ -133,13 +133,13 @@ ol.style.Polygon = function(options) {
'Stroke or fill properties must be provided'); 'Stroke or fill properties must be provided');
/** /**
* @type {ol.expression.Expression} * @type {ol.expr.Expression}
* @private * @private
*/ */
this.opacity_ = !goog.isDef(options.opacity) ? this.opacity_ = !goog.isDef(options.opacity) ?
new ol.expression.Literal(ol.style.PolygonDefaults.opacity) : new ol.expr.Literal(ol.style.PolygonDefaults.opacity) :
(options.opacity instanceof ol.expression.Expression) ? (options.opacity instanceof ol.expr.Expression) ?
options.opacity : new ol.expression.Literal(options.opacity); options.opacity : new ol.expr.Literal(options.opacity);
}; };
goog.inherits(ol.style.Polygon, ol.style.Symbolizer); goog.inherits(ol.style.Polygon, ol.style.Symbolizer);
@@ -153,19 +153,19 @@ ol.style.Polygon.prototype.createLiteral = function(opt_feature) {
var fillColor; var fillColor;
if (!goog.isNull(this.fillColor_)) { if (!goog.isNull(this.fillColor_)) {
fillColor = ol.expression.evaluateFeature(this.fillColor_, opt_feature); fillColor = ol.expr.evaluateFeature(this.fillColor_, opt_feature);
goog.asserts.assertString(fillColor, 'fillColor must be a string'); goog.asserts.assertString(fillColor, 'fillColor must be a string');
} }
var strokeColor; var strokeColor;
if (!goog.isNull(this.strokeColor_)) { if (!goog.isNull(this.strokeColor_)) {
strokeColor = ol.expression.evaluateFeature(this.strokeColor_, opt_feature); strokeColor = ol.expr.evaluateFeature(this.strokeColor_, opt_feature);
goog.asserts.assertString(strokeColor, 'strokeColor must be a string'); goog.asserts.assertString(strokeColor, 'strokeColor must be a string');
} }
var strokeWidth; var strokeWidth;
if (!goog.isNull(this.strokeWidth_)) { if (!goog.isNull(this.strokeWidth_)) {
strokeWidth = ol.expression.evaluateFeature(this.strokeWidth_, opt_feature); strokeWidth = ol.expr.evaluateFeature(this.strokeWidth_, opt_feature);
goog.asserts.assertNumber(strokeWidth, 'strokeWidth must be a number'); goog.asserts.assertNumber(strokeWidth, 'strokeWidth must be a number');
} }
@@ -174,7 +174,7 @@ ol.style.Polygon.prototype.createLiteral = function(opt_feature) {
(goog.isDef(strokeColor) && goog.isDef(strokeWidth)), (goog.isDef(strokeColor) && goog.isDef(strokeWidth)),
'either fillColor or strokeColor and strokeWidth must be defined'); 'either fillColor or strokeColor and strokeWidth must be defined');
var opacity = ol.expression.evaluateFeature(this.opacity_, opt_feature); var opacity = ol.expr.evaluateFeature(this.opacity_, opt_feature);
goog.asserts.assertNumber(opacity, 'opacity must be a number'); goog.asserts.assertNumber(opacity, 'opacity must be a number');
return new ol.style.PolygonLiteral({ return new ol.style.PolygonLiteral({

12
src/ol/style/rule.js
View File

@@ -3,8 +3,8 @@ goog.provide('ol.style.Rule');
goog.require('goog.asserts'); goog.require('goog.asserts');
goog.require('ol.Feature'); goog.require('ol.Feature');
goog.require('ol.expression'); goog.require('ol.expr');
goog.require('ol.expression.Expression'); goog.require('ol.expr.Expression');
goog.require('ol.style.Symbolizer'); goog.require('ol.style.Symbolizer');
@@ -19,15 +19,15 @@ ol.style.Rule = function(options) {
var filter = null; var filter = null;
if (goog.isDef(options.filter)) { if (goog.isDef(options.filter)) {
if (goog.isString(options.filter)) { if (goog.isString(options.filter)) {
filter = ol.expression.parse(options.filter); filter = ol.expr.parse(options.filter);
} else { } else {
goog.asserts.assert(options.filter instanceof ol.expression.Expression); goog.asserts.assert(options.filter instanceof ol.expr.Expression);
filter = options.filter; filter = options.filter;
} }
} }
/** /**
* @type {ol.expression.Expression} * @type {ol.expr.Expression}
* @private * @private
*/ */
this.filter_ = filter; this.filter_ = filter;
@@ -48,7 +48,7 @@ ol.style.Rule = function(options) {
*/ */
ol.style.Rule.prototype.applies = function(feature) { ol.style.Rule.prototype.applies = function(feature) {
return goog.isNull(this.filter_) ? return goog.isNull(this.filter_) ?
true : !!ol.expression.evaluateFeature(this.filter_, feature); true : !!ol.expr.evaluateFeature(this.filter_, feature);
}; };

54
src/ol/style/shape.js
View File

@@ -3,9 +3,9 @@ goog.provide('ol.style.ShapeLiteral');
goog.provide('ol.style.ShapeType'); goog.provide('ol.style.ShapeType');
goog.require('goog.asserts'); goog.require('goog.asserts');
goog.require('ol.expression'); goog.require('ol.expr');
goog.require('ol.expression.Expression'); goog.require('ol.expr.Expression');
goog.require('ol.expression.Literal'); goog.require('ol.expr.Literal');
goog.require('ol.style.Point'); goog.require('ol.style.Point');
goog.require('ol.style.PointLiteral'); goog.require('ol.style.PointLiteral');
@@ -107,22 +107,22 @@ ol.style.Shape = function(options) {
options.type : ol.style.ShapeDefaults.type); options.type : ol.style.ShapeDefaults.type);
/** /**
* @type {ol.expression.Expression} * @type {ol.expr.Expression}
* @private * @private
*/ */
this.size_ = !goog.isDef(options.size) ? this.size_ = !goog.isDef(options.size) ?
new ol.expression.Literal(ol.style.ShapeDefaults.size) : new ol.expr.Literal(ol.style.ShapeDefaults.size) :
(options.size instanceof ol.expression.Expression) ? (options.size instanceof ol.expr.Expression) ?
options.size : new ol.expression.Literal(options.size); options.size : new ol.expr.Literal(options.size);
/** /**
* @type {ol.expression.Expression} * @type {ol.expr.Expression}
* @private * @private
*/ */
this.fillColor_ = !goog.isDefAndNotNull(options.fillColor) ? this.fillColor_ = !goog.isDefAndNotNull(options.fillColor) ?
null : null :
(options.fillColor instanceof ol.expression.Expression) ? (options.fillColor instanceof ol.expr.Expression) ?
options.fillColor : new ol.expression.Literal(options.fillColor); options.fillColor : new ol.expr.Literal(options.fillColor);
// stroke handling - if any stroke property is supplied, use defaults // stroke handling - if any stroke property is supplied, use defaults
var strokeColor = null, var strokeColor = null,
@@ -132,33 +132,33 @@ ol.style.Shape = function(options) {
goog.isDefAndNotNull(options.strokeWidth)) { goog.isDefAndNotNull(options.strokeWidth)) {
if (goog.isDefAndNotNull(options.strokeColor)) { if (goog.isDefAndNotNull(options.strokeColor)) {
strokeColor = (options.strokeColor instanceof ol.expression.Expression) ? strokeColor = (options.strokeColor instanceof ol.expr.Expression) ?
options.strokeColor : options.strokeColor :
new ol.expression.Literal(options.strokeColor); new ol.expr.Literal(options.strokeColor);
} else { } else {
strokeColor = new ol.expression.Literal( strokeColor = new ol.expr.Literal(
/** @type {string} */ (ol.style.ShapeDefaults.strokeColor)); /** @type {string} */ (ol.style.ShapeDefaults.strokeColor));
} }
if (goog.isDefAndNotNull(options.strokeWidth)) { if (goog.isDefAndNotNull(options.strokeWidth)) {
strokeWidth = (options.strokeWidth instanceof ol.expression.Expression) ? strokeWidth = (options.strokeWidth instanceof ol.expr.Expression) ?
options.strokeWidth : options.strokeWidth :
new ol.expression.Literal(options.strokeWidth); new ol.expr.Literal(options.strokeWidth);
} else { } else {
strokeWidth = new ol.expression.Literal( strokeWidth = new ol.expr.Literal(
/** @type {number} */ (ol.style.ShapeDefaults.strokeWidth)); /** @type {number} */ (ol.style.ShapeDefaults.strokeWidth));
} }
} }
/** /**
* @type {ol.expression.Expression} * @type {ol.expr.Expression}
* @private * @private
*/ */
this.strokeColor_ = strokeColor; this.strokeColor_ = strokeColor;
/** /**
* @type {ol.expression.Expression} * @type {ol.expr.Expression}
* @private * @private
*/ */
this.strokeWidth_ = strokeWidth; this.strokeWidth_ = strokeWidth;
@@ -169,13 +169,13 @@ ol.style.Shape = function(options) {
'Stroke or fill properties must be provided'); 'Stroke or fill properties must be provided');
/** /**
* @type {ol.expression.Expression} * @type {ol.expr.Expression}
* @private * @private
*/ */
this.opacity_ = !goog.isDef(options.opacity) ? this.opacity_ = !goog.isDef(options.opacity) ?
new ol.expression.Literal(ol.style.ShapeDefaults.opacity) : new ol.expr.Literal(ol.style.ShapeDefaults.opacity) :
(options.opacity instanceof ol.expression.Expression) ? (options.opacity instanceof ol.expr.Expression) ?
options.opacity : new ol.expression.Literal(options.opacity); options.opacity : new ol.expr.Literal(options.opacity);
}; };
@@ -186,24 +186,24 @@ ol.style.Shape = function(options) {
*/ */
ol.style.Shape.prototype.createLiteral = function(opt_feature) { ol.style.Shape.prototype.createLiteral = function(opt_feature) {
var size = ol.expression.evaluateFeature(this.size_, opt_feature); var size = ol.expr.evaluateFeature(this.size_, opt_feature);
goog.asserts.assertNumber(size, 'size must be a number'); goog.asserts.assertNumber(size, 'size must be a number');
var fillColor; var fillColor;
if (!goog.isNull(this.fillColor_)) { if (!goog.isNull(this.fillColor_)) {
fillColor = ol.expression.evaluateFeature(this.fillColor_, opt_feature); fillColor = ol.expr.evaluateFeature(this.fillColor_, opt_feature);
goog.asserts.assertString(fillColor, 'fillColor must be a string'); goog.asserts.assertString(fillColor, 'fillColor must be a string');
} }
var strokeColor; var strokeColor;
if (!goog.isNull(this.strokeColor_)) { if (!goog.isNull(this.strokeColor_)) {
strokeColor = ol.expression.evaluateFeature(this.strokeColor_, opt_feature); strokeColor = ol.expr.evaluateFeature(this.strokeColor_, opt_feature);
goog.asserts.assertString(strokeColor, 'strokeColor must be a string'); goog.asserts.assertString(strokeColor, 'strokeColor must be a string');
} }
var strokeWidth; var strokeWidth;
if (!goog.isNull(this.strokeWidth_)) { if (!goog.isNull(this.strokeWidth_)) {
strokeWidth = ol.expression.evaluateFeature(this.strokeWidth_, opt_feature); strokeWidth = ol.expr.evaluateFeature(this.strokeWidth_, opt_feature);
goog.asserts.assertNumber(strokeWidth, 'strokeWidth must be a number'); goog.asserts.assertNumber(strokeWidth, 'strokeWidth must be a number');
} }
@@ -212,7 +212,7 @@ ol.style.Shape.prototype.createLiteral = function(opt_feature) {
(goog.isDef(strokeColor) && goog.isDef(strokeWidth)), (goog.isDef(strokeColor) && goog.isDef(strokeWidth)),
'either fillColor or strokeColor and strokeWidth must be defined'); 'either fillColor or strokeColor and strokeWidth must be defined');
var opacity = ol.expression.evaluateFeature(this.opacity_, opt_feature); var opacity = ol.expr.evaluateFeature(this.opacity_, opt_feature);
goog.asserts.assertNumber(opacity, 'opacity must be a number'); goog.asserts.assertNumber(opacity, 'opacity must be a number');
return new ol.style.ShapeLiteral({ return new ol.style.ShapeLiteral({

54
src/ol/style/text.js
View File

@@ -2,9 +2,9 @@ goog.provide('ol.style.Text');
goog.provide('ol.style.TextLiteral'); goog.provide('ol.style.TextLiteral');
goog.require('goog.asserts'); goog.require('goog.asserts');
goog.require('ol.expression'); goog.require('ol.expr');
goog.require('ol.expression.Expression'); goog.require('ol.expr.Expression');
goog.require('ol.expression.Literal'); goog.require('ol.expr.Literal');
goog.require('ol.style.Symbolizer'); goog.require('ol.style.Symbolizer');
goog.require('ol.style.SymbolizerLiteral'); goog.require('ol.style.SymbolizerLiteral');
@@ -71,47 +71,47 @@ ol.style.TextLiteral.prototype.equals = function(textLiteral) {
ol.style.Text = function(options) { ol.style.Text = function(options) {
/** /**
* @type {ol.expression.Expression} * @type {ol.expr.Expression}
* @private * @private
*/ */
this.color_ = !goog.isDef(options.color) ? this.color_ = !goog.isDef(options.color) ?
new ol.expression.Literal(ol.style.TextDefaults.color) : new ol.expr.Literal(ol.style.TextDefaults.color) :
(options.color instanceof ol.expression.Expression) ? (options.color instanceof ol.expr.Expression) ?
options.color : new ol.expression.Literal(options.color); options.color : new ol.expr.Literal(options.color);
/** /**
* @type {ol.expression.Expression} * @type {ol.expr.Expression}
* @private * @private
*/ */
this.fontFamily_ = !goog.isDef(options.fontFamily) ? this.fontFamily_ = !goog.isDef(options.fontFamily) ?
new ol.expression.Literal(ol.style.TextDefaults.fontFamily) : new ol.expr.Literal(ol.style.TextDefaults.fontFamily) :
(options.fontFamily instanceof ol.expression.Expression) ? (options.fontFamily instanceof ol.expr.Expression) ?
options.fontFamily : new ol.expression.Literal(options.fontFamily); options.fontFamily : new ol.expr.Literal(options.fontFamily);
/** /**
* @type {ol.expression.Expression} * @type {ol.expr.Expression}
* @private * @private
*/ */
this.fontSize_ = !goog.isDef(options.fontSize) ? this.fontSize_ = !goog.isDef(options.fontSize) ?
new ol.expression.Literal(ol.style.TextDefaults.fontSize) : new ol.expr.Literal(ol.style.TextDefaults.fontSize) :
(options.fontSize instanceof ol.expression.Expression) ? (options.fontSize instanceof ol.expr.Expression) ?
options.fontSize : new ol.expression.Literal(options.fontSize); options.fontSize : new ol.expr.Literal(options.fontSize);
/** /**
* @type {ol.expression.Expression} * @type {ol.expr.Expression}
* @private * @private
*/ */
this.text_ = (options.text instanceof ol.expression.Expression) ? this.text_ = (options.text instanceof ol.expr.Expression) ?
options.text : new ol.expression.Literal(options.text); options.text : new ol.expr.Literal(options.text);
/** /**
* @type {ol.expression.Expression} * @type {ol.expr.Expression}
* @private * @private
*/ */
this.opacity_ = !goog.isDef(options.opacity) ? this.opacity_ = !goog.isDef(options.opacity) ?
new ol.expression.Literal(ol.style.TextDefaults.opacity) : new ol.expr.Literal(ol.style.TextDefaults.opacity) :
(options.opacity instanceof ol.expression.Expression) ? (options.opacity instanceof ol.expr.Expression) ?
options.opacity : new ol.expression.Literal(options.opacity); options.opacity : new ol.expr.Literal(options.opacity);
}; };
goog.inherits(ol.style.Text, ol.style.Symbolizer); goog.inherits(ol.style.Text, ol.style.Symbolizer);
@@ -123,19 +123,19 @@ goog.inherits(ol.style.Text, ol.style.Symbolizer);
*/ */
ol.style.Text.prototype.createLiteral = function(opt_feature) { ol.style.Text.prototype.createLiteral = function(opt_feature) {
var color = ol.expression.evaluateFeature(this.color_, opt_feature); var color = ol.expr.evaluateFeature(this.color_, opt_feature);
goog.asserts.assertString(color, 'color must be a string'); goog.asserts.assertString(color, 'color must be a string');
var fontFamily = ol.expression.evaluateFeature(this.fontFamily_, opt_feature); var fontFamily = ol.expr.evaluateFeature(this.fontFamily_, opt_feature);
goog.asserts.assertString(fontFamily, 'fontFamily must be a string'); goog.asserts.assertString(fontFamily, 'fontFamily must be a string');
var fontSize = ol.expression.evaluateFeature(this.fontSize_, opt_feature); var fontSize = ol.expr.evaluateFeature(this.fontSize_, opt_feature);
goog.asserts.assertNumber(fontSize, 'fontSize must be a number'); goog.asserts.assertNumber(fontSize, 'fontSize must be a number');
var text = ol.expression.evaluateFeature(this.text_, opt_feature); var text = ol.expr.evaluateFeature(this.text_, opt_feature);
goog.asserts.assertString(text, 'text must be a string'); goog.asserts.assertString(text, 'text must be a string');
var opacity = ol.expression.evaluateFeature(this.opacity_, opt_feature); var opacity = ol.expr.evaluateFeature(this.opacity_, opt_feature);
goog.asserts.assertNumber(opacity, 'opacity must be a number'); goog.asserts.assertNumber(opacity, 'opacity must be a number');
return new ol.style.TextLiteral({ return new ol.style.TextLiteral({

290
test/spec/ol/expression/expression.test.js → test/spec/ol/expr/expression.test.js
View File

@@ -1,33 +1,33 @@
goog.provide('ol.test.expression'); goog.provide('ol.test.expression');
describe('ol.expression.parse()', function() { describe('ol.expr.parse()', function() {
it('parses a subset of ECMAScript 5.1 expressions', function() { it('parses a subset of ECMAScript 5.1 expressions', function() {
var expr = ol.expression.parse('foo'); var expr = ol.expr.parse('foo');
expect(expr).to.be.a(ol.expression.Expression); expect(expr).to.be.a(ol.expr.Expression);
}); });
describe('11.1 - primary expressions', function() { describe('11.1 - primary expressions', function() {
// http://www.ecma-international.org/ecma-262/5.1/#sec-11.1 // http://www.ecma-international.org/ecma-262/5.1/#sec-11.1
it('parses identifier expressions', function() { it('parses identifier expressions', function() {
var expr = ol.expression.parse('foo'); var expr = ol.expr.parse('foo');
expect(expr).to.be.a(ol.expression.Identifier); expect(expr).to.be.a(ol.expr.Identifier);
expect(expr.evaluate({foo: 'bar'})).to.be('bar'); expect(expr.evaluate({foo: 'bar'})).to.be('bar');
}); });
it('consumes whitespace as expected', function() { it('consumes whitespace as expected', function() {
var expr = ol.expression.parse(' foo '); var expr = ol.expr.parse(' foo ');
expect(expr).to.be.a(ol.expression.Identifier); expect(expr).to.be.a(ol.expr.Identifier);
expect(expr.evaluate({foo: 'bar'})).to.be('bar'); expect(expr.evaluate({foo: 'bar'})).to.be('bar');
}); });
it('throws on invalid identifier expressions', function() { it('throws on invalid identifier expressions', function() {
expect(function() { expect(function() {
ol.expression.parse('3foo'); ol.expr.parse('3foo');
}).throwException(function(err) { }).throwException(function(err) {
expect(err).to.be.an(ol.expression.UnexpectedToken); expect(err).to.be.an(ol.expr.UnexpectedToken);
var token = err.token; var token = err.token;
expect(token.value).to.be('f'); expect(token.value).to.be('f');
expect(token.index).to.be(1); expect(token.index).to.be(1);
@@ -35,33 +35,33 @@ describe('ol.expression.parse()', function() {
}); });
it('parses string literal expressions', function() { it('parses string literal expressions', function() {
var expr = ol.expression.parse('"foo"'); var expr = ol.expr.parse('"foo"');
expect(expr).to.be.a(ol.expression.Literal); expect(expr).to.be.a(ol.expr.Literal);
expect(expr.evaluate()).to.be('foo'); expect(expr.evaluate()).to.be('foo');
}); });
it('throws on unterminated string', function() { it('throws on unterminated string', function() {
expect(function() { expect(function() {
ol.expression.parse('"foo'); ol.expr.parse('"foo');
}).throwException(function(err) { }).throwException(function(err) {
expect(err).to.be.an(ol.expression.UnexpectedToken); expect(err).to.be.an(ol.expr.UnexpectedToken);
var token = err.token; var token = err.token;
expect(token.type).to.be(ol.expression.TokenType.EOF); expect(token.type).to.be(ol.expr.TokenType.EOF);
expect(token.index).to.be(4); expect(token.index).to.be(4);
}); });
}); });
it('parses numeric literal expressions', function() { it('parses numeric literal expressions', function() {
var expr = ol.expression.parse('.42e+2'); var expr = ol.expr.parse('.42e+2');
expect(expr).to.be.a(ol.expression.Literal); expect(expr).to.be.a(ol.expr.Literal);
expect(expr.evaluate()).to.be(42); expect(expr.evaluate()).to.be(42);
}); });
it('throws on invalid number', function() { it('throws on invalid number', function() {
expect(function() { expect(function() {
ol.expression.parse('.42eX'); ol.expr.parse('.42eX');
}).throwException(function(err) { }).throwException(function(err) {
expect(err).to.be.an(ol.expression.UnexpectedToken); expect(err).to.be.an(ol.expr.UnexpectedToken);
var token = err.token; var token = err.token;
expect(token.value).to.be('X'); expect(token.value).to.be('X');
expect(token.index).to.be(4); expect(token.index).to.be(4);
@@ -69,14 +69,14 @@ describe('ol.expression.parse()', function() {
}); });
it('parses boolean literal expressions', function() { it('parses boolean literal expressions', function() {
var expr = ol.expression.parse('false'); var expr = ol.expr.parse('false');
expect(expr).to.be.a(ol.expression.Literal); expect(expr).to.be.a(ol.expr.Literal);
expect(expr.evaluate()).to.be(false); expect(expr.evaluate()).to.be(false);
}); });
it('parses null literal expressions', function() { it('parses null literal expressions', function() {
var expr = ol.expression.parse('null'); var expr = ol.expr.parse('null');
expect(expr).to.be.a(ol.expression.Literal); expect(expr).to.be.a(ol.expr.Literal);
expect(expr.evaluate()).to.be(null); expect(expr.evaluate()).to.be(null);
}); });
@@ -86,24 +86,24 @@ describe('ol.expression.parse()', function() {
// http://www.ecma-international.org/ecma-262/5.1/#sec-11.2 // http://www.ecma-international.org/ecma-262/5.1/#sec-11.2
it('parses member expressions with dot notation', function() { it('parses member expressions with dot notation', function() {
var expr = ol.expression.parse('foo.bar.baz'); var expr = ol.expr.parse('foo.bar.baz');
expect(expr).to.be.a(ol.expression.Member); expect(expr).to.be.a(ol.expr.Member);
var scope = {foo: {bar: {baz: 42}}}; var scope = {foo: {bar: {baz: 42}}};
expect(expr.evaluate(scope)).to.be(42); expect(expr.evaluate(scope)).to.be(42);
}); });
it('consumes whitespace as expected', function() { it('consumes whitespace as expected', function() {
var expr = ol.expression.parse(' foo . bar . baz '); var expr = ol.expr.parse(' foo . bar . baz ');
expect(expr).to.be.a(ol.expression.Member); expect(expr).to.be.a(ol.expr.Member);
var scope = {foo: {bar: {baz: 42}}}; var scope = {foo: {bar: {baz: 42}}};
expect(expr.evaluate(scope)).to.be(42); expect(expr.evaluate(scope)).to.be(42);
}); });
it('throws on invalid member expression', function() { it('throws on invalid member expression', function() {
expect(function() { expect(function() {
ol.expression.parse('foo.4bar'); ol.expr.parse('foo.4bar');
}).throwException(function(err) { }).throwException(function(err) {
expect(err).to.be.an(ol.expression.UnexpectedToken); expect(err).to.be.an(ol.expr.UnexpectedToken);
var token = err.token; var token = err.token;
expect(token.value).to.be('b'); expect(token.value).to.be('b');
expect(token.index).to.be(5); expect(token.index).to.be(5);
@@ -111,8 +111,8 @@ describe('ol.expression.parse()', function() {
}); });
it('parses call expressions with literal arguments', function() { it('parses call expressions with literal arguments', function() {
var expr = ol.expression.parse('foo(42, "bar")'); var expr = ol.expr.parse('foo(42, "bar")');
expect(expr).to.be.a(ol.expression.Call); expect(expr).to.be.a(ol.expr.Call);
var scope = { var scope = {
foo: function(num, str) { foo: function(num, str) {
expect(num).to.be(42); expect(num).to.be(42);
@@ -125,9 +125,9 @@ describe('ol.expression.parse()', function() {
it('throws on calls with unterminated arguments', function() { it('throws on calls with unterminated arguments', function() {
expect(function() { expect(function() {
ol.expression.parse('foo(42,)'); ol.expr.parse('foo(42,)');
}).throwException(function(err) { }).throwException(function(err) {
expect(err).to.be.an(ol.expression.UnexpectedToken); expect(err).to.be.an(ol.expr.UnexpectedToken);
var token = err.token; var token = err.token;
expect(token.value).to.be(')'); expect(token.value).to.be(')');
expect(token.index).to.be(7); expect(token.index).to.be(7);
@@ -146,8 +146,8 @@ describe('ol.expression.parse()', function() {
// http://www.ecma-international.org/ecma-262/5.1/#sec-11.4 // http://www.ecma-international.org/ecma-262/5.1/#sec-11.4
it('parses logical not operator', function() { it('parses logical not operator', function() {
var expr = ol.expression.parse('!foo'); var expr = ol.expr.parse('!foo');
expect(expr).to.be.a(ol.expression.Not); expect(expr).to.be.a(ol.expr.Not);
expect(expr.evaluate({foo: true})).to.be(false); expect(expr.evaluate({foo: true})).to.be(false);
expect(expr.evaluate({foo: false})).to.be(true); expect(expr.evaluate({foo: false})).to.be(true);
expect(expr.evaluate({foo: ''})).to.be(true); expect(expr.evaluate({foo: ''})).to.be(true);
@@ -155,8 +155,8 @@ describe('ol.expression.parse()', function() {
}); });
it('consumes whitespace as expected', function() { it('consumes whitespace as expected', function() {
var expr = ol.expression.parse(' ! foo'); var expr = ol.expr.parse(' ! foo');
expect(expr).to.be.a(ol.expression.Not); expect(expr).to.be.a(ol.expr.Not);
expect(expr.evaluate({foo: true})).to.be(false); expect(expr.evaluate({foo: true})).to.be(false);
expect(expr.evaluate({foo: false})).to.be(true); expect(expr.evaluate({foo: false})).to.be(true);
}); });
@@ -167,38 +167,38 @@ describe('ol.expression.parse()', function() {
// http://www.ecma-international.org/ecma-262/5.1/#sec-11.5 // http://www.ecma-international.org/ecma-262/5.1/#sec-11.5
it('parses * operator', function() { it('parses * operator', function() {
var expr = ol.expression.parse('foo*bar'); var expr = ol.expr.parse('foo*bar');
expect(expr).to.be.a(ol.expression.Math); expect(expr).to.be.a(ol.expr.Math);
expect(expr.evaluate({foo: 10, bar: 20})).to.be(200); expect(expr.evaluate({foo: 10, bar: 20})).to.be(200);
}); });
it('consumes whitespace as expected with *', function() { it('consumes whitespace as expected with *', function() {
var expr = ol.expression.parse(' foo * bar '); var expr = ol.expr.parse(' foo * bar ');
expect(expr).to.be.a(ol.expression.Math); expect(expr).to.be.a(ol.expr.Math);
expect(expr.evaluate({foo: 15, bar: 2})).to.be(30); expect(expr.evaluate({foo: 15, bar: 2})).to.be(30);
}); });
it('parses / operator', function() { it('parses / operator', function() {
var expr = ol.expression.parse('foo/12'); var expr = ol.expr.parse('foo/12');
expect(expr).to.be.a(ol.expression.Math); expect(expr).to.be.a(ol.expr.Math);
expect(expr.evaluate({foo: 10})).to.be(10 / 12); expect(expr.evaluate({foo: 10})).to.be(10 / 12);
}); });
it('consumes whitespace as expected with /', function() { it('consumes whitespace as expected with /', function() {
var expr = ol.expression.parse(' 4 / bar '); var expr = ol.expr.parse(' 4 / bar ');
expect(expr).to.be.a(ol.expression.Math); expect(expr).to.be.a(ol.expr.Math);
expect(expr.evaluate({bar: 3})).to.be(4 / 3); expect(expr.evaluate({bar: 3})).to.be(4 / 3);
}); });
it('parses % operator', function() { it('parses % operator', function() {
var expr = ol.expression.parse('12%foo'); var expr = ol.expr.parse('12%foo');
expect(expr).to.be.a(ol.expression.Math); expect(expr).to.be.a(ol.expr.Math);
expect(expr.evaluate({foo: 10})).to.be(2); expect(expr.evaluate({foo: 10})).to.be(2);
}); });
it('consumes whitespace as expected with %', function() { it('consumes whitespace as expected with %', function() {
var expr = ol.expression.parse(' 4 %bar '); var expr = ol.expr.parse(' 4 %bar ');
expect(expr).to.be.a(ol.expression.Math); expect(expr).to.be.a(ol.expr.Math);
expect(expr.evaluate({bar: 3})).to.be(1); expect(expr.evaluate({bar: 3})).to.be(1);
}); });
@@ -208,26 +208,26 @@ describe('ol.expression.parse()', function() {
// http://www.ecma-international.org/ecma-262/5.1/#sec-11.6 // http://www.ecma-international.org/ecma-262/5.1/#sec-11.6
it('parses + operator', function() { it('parses + operator', function() {
var expr = ol.expression.parse('foo+bar'); var expr = ol.expr.parse('foo+bar');
expect(expr).to.be.a(ol.expression.Math); expect(expr).to.be.a(ol.expr.Math);
expect(expr.evaluate({foo: 10, bar: 20})).to.be(30); expect(expr.evaluate({foo: 10, bar: 20})).to.be(30);
}); });
it('consumes whitespace as expected with +', function() { it('consumes whitespace as expected with +', function() {
var expr = ol.expression.parse(' foo +10 '); var expr = ol.expr.parse(' foo +10 ');
expect(expr).to.be.a(ol.expression.Math); expect(expr).to.be.a(ol.expr.Math);
expect(expr.evaluate({foo: 15})).to.be(25); expect(expr.evaluate({foo: 15})).to.be(25);
}); });
it('parses - operator', function() { it('parses - operator', function() {
var expr = ol.expression.parse('foo-bar'); var expr = ol.expr.parse('foo-bar');
expect(expr).to.be.a(ol.expression.Math); expect(expr).to.be.a(ol.expr.Math);
expect(expr.evaluate({foo: 10, bar: 20})).to.be(-10); expect(expr.evaluate({foo: 10, bar: 20})).to.be(-10);
}); });
it('consumes whitespace as expected with -', function() { it('consumes whitespace as expected with -', function() {
var expr = ol.expression.parse(' foo- 10 '); var expr = ol.expr.parse(' foo- 10 ');
expect(expr).to.be.a(ol.expression.Math); expect(expr).to.be.a(ol.expr.Math);
expect(expr.evaluate({foo: 15})).to.be(5); expect(expr.evaluate({foo: 15})).to.be(5);
}); });
@@ -242,44 +242,44 @@ describe('ol.expression.parse()', function() {
// http://www.ecma-international.org/ecma-262/5.1/#sec-11.8 // http://www.ecma-international.org/ecma-262/5.1/#sec-11.8
it('parses < operator', function() { it('parses < operator', function() {
var expr = ol.expression.parse('foo<bar'); var expr = ol.expr.parse('foo<bar');
expect(expr).to.be.a(ol.expression.Comparison); expect(expr).to.be.a(ol.expr.Comparison);
expect(expr.evaluate({foo: 10, bar: 20})).to.be(true); expect(expr.evaluate({foo: 10, bar: 20})).to.be(true);
expect(expr.evaluate({foo: 100, bar: 20})).to.be(false); expect(expr.evaluate({foo: 100, bar: 20})).to.be(false);
}); });
it('consumes whitespace as expected with <', function() { it('consumes whitespace as expected with <', function() {
var expr = ol.expression.parse(' foo <10 '); var expr = ol.expr.parse(' foo <10 ');
expect(expr).to.be.a(ol.expression.Comparison); expect(expr).to.be.a(ol.expr.Comparison);
expect(expr.evaluate({foo: 15})).to.be(false); expect(expr.evaluate({foo: 15})).to.be(false);
expect(expr.evaluate({foo: 5})).to.be(true); expect(expr.evaluate({foo: 5})).to.be(true);
}); });
it('parses > operator', function() { it('parses > operator', function() {
var expr = ol.expression.parse('foo>bar'); var expr = ol.expr.parse('foo>bar');
expect(expr).to.be.a(ol.expression.Comparison); expect(expr).to.be.a(ol.expr.Comparison);
expect(expr.evaluate({foo: 10, bar: 20})).to.be(false); expect(expr.evaluate({foo: 10, bar: 20})).to.be(false);
expect(expr.evaluate({foo: 100, bar: 20})).to.be(true); expect(expr.evaluate({foo: 100, bar: 20})).to.be(true);
}); });
it('consumes whitespace as expected with >', function() { it('consumes whitespace as expected with >', function() {
var expr = ol.expression.parse(' foo> 10 '); var expr = ol.expr.parse(' foo> 10 ');
expect(expr).to.be.a(ol.expression.Comparison); expect(expr).to.be.a(ol.expr.Comparison);
expect(expr.evaluate({foo: 15})).to.be(true); expect(expr.evaluate({foo: 15})).to.be(true);
expect(expr.evaluate({foo: 5})).to.be(false); expect(expr.evaluate({foo: 5})).to.be(false);
}); });
it('parses <= operator', function() { it('parses <= operator', function() {
var expr = ol.expression.parse('foo<=bar'); var expr = ol.expr.parse('foo<=bar');
expect(expr).to.be.a(ol.expression.Comparison); expect(expr).to.be.a(ol.expr.Comparison);
expect(expr.evaluate({foo: 10, bar: 20})).to.be(true); expect(expr.evaluate({foo: 10, bar: 20})).to.be(true);
expect(expr.evaluate({foo: 100, bar: 20})).to.be(false); expect(expr.evaluate({foo: 100, bar: 20})).to.be(false);
expect(expr.evaluate({foo: 20, bar: 20})).to.be(true); expect(expr.evaluate({foo: 20, bar: 20})).to.be(true);
}); });
it('consumes whitespace as expected with <=', function() { it('consumes whitespace as expected with <=', function() {
var expr = ol.expression.parse(' foo<= 10 '); var expr = ol.expr.parse(' foo<= 10 ');
expect(expr).to.be.a(ol.expression.Comparison); expect(expr).to.be.a(ol.expr.Comparison);
expect(expr.evaluate({foo: 15})).to.be(false); expect(expr.evaluate({foo: 15})).to.be(false);
expect(expr.evaluate({foo: 5})).to.be(true); expect(expr.evaluate({foo: 5})).to.be(true);
expect(expr.evaluate({foo: 10})).to.be(true); expect(expr.evaluate({foo: 10})).to.be(true);
@@ -287,9 +287,9 @@ describe('ol.expression.parse()', function() {
it('throws for invalid spacing with <=', function() { it('throws for invalid spacing with <=', function() {
expect(function() { expect(function() {
ol.expression.parse(' foo< = 10 '); ol.expr.parse(' foo< = 10 ');
}).throwException(function(err) { }).throwException(function(err) {
expect(err).to.be.an(ol.expression.UnexpectedToken); expect(err).to.be.an(ol.expr.UnexpectedToken);
var token = err.token; var token = err.token;
expect(token.value).to.be('='); expect(token.value).to.be('=');
expect(token.index).to.be(6); expect(token.index).to.be(6);
@@ -297,16 +297,16 @@ describe('ol.expression.parse()', function() {
}); });
it('parses >= operator', function() { it('parses >= operator', function() {
var expr = ol.expression.parse('foo>=bar'); var expr = ol.expr.parse('foo>=bar');
expect(expr).to.be.a(ol.expression.Comparison); expect(expr).to.be.a(ol.expr.Comparison);
expect(expr.evaluate({foo: 10, bar: 20})).to.be(false); expect(expr.evaluate({foo: 10, bar: 20})).to.be(false);
expect(expr.evaluate({foo: 100, bar: 20})).to.be(true); expect(expr.evaluate({foo: 100, bar: 20})).to.be(true);
expect(expr.evaluate({foo: 20, bar: 20})).to.be(true); expect(expr.evaluate({foo: 20, bar: 20})).to.be(true);
}); });
it('consumes whitespace as expected with >=', function() { it('consumes whitespace as expected with >=', function() {
var expr = ol.expression.parse(' foo >=10 '); var expr = ol.expr.parse(' foo >=10 ');
expect(expr).to.be.a(ol.expression.Comparison); expect(expr).to.be.a(ol.expr.Comparison);
expect(expr.evaluate({foo: 15})).to.be(true); expect(expr.evaluate({foo: 15})).to.be(true);
expect(expr.evaluate({foo: 5})).to.be(false); expect(expr.evaluate({foo: 5})).to.be(false);
expect(expr.evaluate({foo: 10})).to.be(true); expect(expr.evaluate({foo: 10})).to.be(true);
@@ -314,9 +314,9 @@ describe('ol.expression.parse()', function() {
it('throws for invalid spacing with >=', function() { it('throws for invalid spacing with >=', function() {
expect(function() { expect(function() {
ol.expression.parse(' 10 > =foo '); ol.expr.parse(' 10 > =foo ');
}).throwException(function(err) { }).throwException(function(err) {
expect(err).to.be.an(ol.expression.UnexpectedToken); expect(err).to.be.an(ol.expr.UnexpectedToken);
var token = err.token; var token = err.token;
expect(token.value).to.be('='); expect(token.value).to.be('=');
expect(token.index).to.be(6); expect(token.index).to.be(6);
@@ -329,16 +329,16 @@ describe('ol.expression.parse()', function() {
// http://www.ecma-international.org/ecma-262/5.1/#sec-11.9 // http://www.ecma-international.org/ecma-262/5.1/#sec-11.9
it('parses == operator', function() { it('parses == operator', function() {
var expr = ol.expression.parse('foo==42'); var expr = ol.expr.parse('foo==42');
expect(expr).to.be.a(ol.expression.Comparison); expect(expr).to.be.a(ol.expr.Comparison);
expect(expr.evaluate({foo: 42})).to.be(true); expect(expr.evaluate({foo: 42})).to.be(true);
expect(expr.evaluate({foo: 41})).to.be(false); expect(expr.evaluate({foo: 41})).to.be(false);
expect(expr.evaluate({foo: '42'})).to.be(true); expect(expr.evaluate({foo: '42'})).to.be(true);
}); });
it('consumes whitespace as expected with ==', function() { it('consumes whitespace as expected with ==', function() {
var expr = ol.expression.parse(' 42 ==foo '); var expr = ol.expr.parse(' 42 ==foo ');
expect(expr).to.be.a(ol.expression.Comparison); expect(expr).to.be.a(ol.expr.Comparison);
expect(expr.evaluate({foo: 42})).to.be(true); expect(expr.evaluate({foo: 42})).to.be(true);
expect(expr.evaluate({foo: 41})).to.be(false); expect(expr.evaluate({foo: 41})).to.be(false);
expect(expr.evaluate({foo: '42'})).to.be(true); expect(expr.evaluate({foo: '42'})).to.be(true);
@@ -346,9 +346,9 @@ describe('ol.expression.parse()', function() {
it('throws for invalid spacing with ==', function() { it('throws for invalid spacing with ==', function() {
expect(function() { expect(function() {
ol.expression.parse(' 10 = =foo '); ol.expr.parse(' 10 = =foo ');
}).throwException(function(err) { }).throwException(function(err) {
expect(err).to.be.an(ol.expression.UnexpectedToken); expect(err).to.be.an(ol.expr.UnexpectedToken);
var token = err.token; var token = err.token;
expect(token.value).to.be('='); expect(token.value).to.be('=');
expect(token.index).to.be(4); expect(token.index).to.be(4);
@@ -356,16 +356,16 @@ describe('ol.expression.parse()', function() {
}); });
it('parses != operator', function() { it('parses != operator', function() {
var expr = ol.expression.parse('foo!=42'); var expr = ol.expr.parse('foo!=42');
expect(expr).to.be.a(ol.expression.Comparison); expect(expr).to.be.a(ol.expr.Comparison);
expect(expr.evaluate({foo: 42})).to.be(false); expect(expr.evaluate({foo: 42})).to.be(false);
expect(expr.evaluate({foo: 41})).to.be(true); expect(expr.evaluate({foo: 41})).to.be(true);
expect(expr.evaluate({foo: '42'})).to.be(false); expect(expr.evaluate({foo: '42'})).to.be(false);
}); });
it('consumes whitespace as expected with !=', function() { it('consumes whitespace as expected with !=', function() {
var expr = ol.expression.parse(' 42 !=foo '); var expr = ol.expr.parse(' 42 !=foo ');
expect(expr).to.be.a(ol.expression.Comparison); expect(expr).to.be.a(ol.expr.Comparison);
expect(expr.evaluate({foo: 42})).to.be(false); expect(expr.evaluate({foo: 42})).to.be(false);
expect(expr.evaluate({foo: 41})).to.be(true); expect(expr.evaluate({foo: 41})).to.be(true);
expect(expr.evaluate({foo: '42'})).to.be(false); expect(expr.evaluate({foo: '42'})).to.be(false);
@@ -373,9 +373,9 @@ describe('ol.expression.parse()', function() {
it('throws for invalid spacing with !=', function() { it('throws for invalid spacing with !=', function() {
expect(function() { expect(function() {
ol.expression.parse(' 10! =foo '); ol.expr.parse(' 10! =foo ');
}).throwException(function(err) { }).throwException(function(err) {
expect(err).to.be.an(ol.expression.UnexpectedToken); expect(err).to.be.an(ol.expr.UnexpectedToken);
var token = err.token; var token = err.token;
expect(token.value).to.be('!'); expect(token.value).to.be('!');
expect(token.index).to.be(3); expect(token.index).to.be(3);
@@ -383,16 +383,16 @@ describe('ol.expression.parse()', function() {
}); });
it('parses === operator', function() { it('parses === operator', function() {
var expr = ol.expression.parse('42===foo'); var expr = ol.expr.parse('42===foo');
expect(expr).to.be.a(ol.expression.Comparison); expect(expr).to.be.a(ol.expr.Comparison);
expect(expr.evaluate({foo: 42})).to.be(true); expect(expr.evaluate({foo: 42})).to.be(true);
expect(expr.evaluate({foo: 41})).to.be(false); expect(expr.evaluate({foo: 41})).to.be(false);
expect(expr.evaluate({foo: '42'})).to.be(false); expect(expr.evaluate({foo: '42'})).to.be(false);
}); });
it('consumes whitespace as expected with ===', function() { it('consumes whitespace as expected with ===', function() {
var expr = ol.expression.parse(' foo ===42 '); var expr = ol.expr.parse(' foo ===42 ');
expect(expr).to.be.a(ol.expression.Comparison); expect(expr).to.be.a(ol.expr.Comparison);
expect(expr.evaluate({foo: 42})).to.be(true); expect(expr.evaluate({foo: 42})).to.be(true);
expect(expr.evaluate({foo: 41})).to.be(false); expect(expr.evaluate({foo: 41})).to.be(false);
expect(expr.evaluate({foo: '42'})).to.be(false); expect(expr.evaluate({foo: '42'})).to.be(false);
@@ -400,9 +400,9 @@ describe('ol.expression.parse()', function() {
it('throws for invalid spacing with ===', function() { it('throws for invalid spacing with ===', function() {
expect(function() { expect(function() {
ol.expression.parse(' 10 = == foo '); ol.expr.parse(' 10 = == foo ');
}).throwException(function(err) { }).throwException(function(err) {
expect(err).to.be.an(ol.expression.UnexpectedToken); expect(err).to.be.an(ol.expr.UnexpectedToken);
var token = err.token; var token = err.token;
expect(token.value).to.be('='); expect(token.value).to.be('=');
expect(token.index).to.be(4); expect(token.index).to.be(4);
@@ -410,16 +410,16 @@ describe('ol.expression.parse()', function() {
}); });
it('parses !== operator', function() { it('parses !== operator', function() {
var expr = ol.expression.parse('foo!==42'); var expr = ol.expr.parse('foo!==42');
expect(expr).to.be.a(ol.expression.Comparison); expect(expr).to.be.a(ol.expr.Comparison);
expect(expr.evaluate({foo: 42})).to.be(false); expect(expr.evaluate({foo: 42})).to.be(false);
expect(expr.evaluate({foo: 41})).to.be(true); expect(expr.evaluate({foo: 41})).to.be(true);
expect(expr.evaluate({foo: '42'})).to.be(true); expect(expr.evaluate({foo: '42'})).to.be(true);
}); });
it('consumes whitespace as expected with !==', function() { it('consumes whitespace as expected with !==', function() {
var expr = ol.expression.parse(' 42 !== foo '); var expr = ol.expr.parse(' 42 !== foo ');
expect(expr).to.be.a(ol.expression.Comparison); expect(expr).to.be.a(ol.expr.Comparison);
expect(expr.evaluate({foo: 42})).to.be(false); expect(expr.evaluate({foo: 42})).to.be(false);
expect(expr.evaluate({foo: 41})).to.be(true); expect(expr.evaluate({foo: 41})).to.be(true);
expect(expr.evaluate({foo: '42'})).to.be(true); expect(expr.evaluate({foo: '42'})).to.be(true);
@@ -427,9 +427,9 @@ describe('ol.expression.parse()', function() {
it('throws for invalid spacing with !==', function() { it('throws for invalid spacing with !==', function() {
expect(function() { expect(function() {
ol.expression.parse(' 10 != = foo '); ol.expr.parse(' 10 != = foo ');
}).throwException(function(err) { }).throwException(function(err) {
expect(err).to.be.an(ol.expression.UnexpectedToken); expect(err).to.be.an(ol.expr.UnexpectedToken);
var token = err.token; var token = err.token;
expect(token.value).to.be('='); expect(token.value).to.be('=');
expect(token.index).to.be(7); expect(token.index).to.be(7);
@@ -446,8 +446,8 @@ describe('ol.expression.parse()', function() {
// http://www.ecma-international.org/ecma-262/5.1/#sec-11.11 // http://www.ecma-international.org/ecma-262/5.1/#sec-11.11
it('parses && operator', function() { it('parses && operator', function() {
var expr = ol.expression.parse('foo&&bar'); var expr = ol.expr.parse('foo&&bar');
expect(expr).to.be.a(ol.expression.Logical); expect(expr).to.be.a(ol.expr.Logical);
expect(expr.evaluate({foo: true, bar: true})).to.be(true); expect(expr.evaluate({foo: true, bar: true})).to.be(true);
expect(expr.evaluate({foo: true, bar: false})).to.be(false); expect(expr.evaluate({foo: true, bar: false})).to.be(false);
expect(expr.evaluate({foo: false, bar: true})).to.be(false); expect(expr.evaluate({foo: false, bar: true})).to.be(false);
@@ -455,8 +455,8 @@ describe('ol.expression.parse()', function() {
}); });
it('consumes space as expected with &&', function() { it('consumes space as expected with &&', function() {
var expr = ol.expression.parse(' foo && bar '); var expr = ol.expr.parse(' foo && bar ');
expect(expr).to.be.a(ol.expression.Logical); expect(expr).to.be.a(ol.expr.Logical);
expect(expr.evaluate({foo: true, bar: true})).to.be(true); expect(expr.evaluate({foo: true, bar: true})).to.be(true);
expect(expr.evaluate({foo: true, bar: false})).to.be(false); expect(expr.evaluate({foo: true, bar: false})).to.be(false);
expect(expr.evaluate({foo: false, bar: true})).to.be(false); expect(expr.evaluate({foo: false, bar: true})).to.be(false);
@@ -465,9 +465,9 @@ describe('ol.expression.parse()', function() {
it('throws for invalid spacing with &&', function() { it('throws for invalid spacing with &&', function() {
expect(function() { expect(function() {
ol.expression.parse('true & & false'); ol.expr.parse('true & & false');
}).throwException(function(err) { }).throwException(function(err) {
expect(err).to.be.an(ol.expression.UnexpectedToken); expect(err).to.be.an(ol.expr.UnexpectedToken);
var token = err.token; var token = err.token;
expect(token.value).to.be('&'); expect(token.value).to.be('&');
expect(token.index).to.be(5); expect(token.index).to.be(5);
@@ -475,8 +475,8 @@ describe('ol.expression.parse()', function() {
}); });
it('parses || operator', function() { it('parses || operator', function() {
var expr = ol.expression.parse('foo||bar'); var expr = ol.expr.parse('foo||bar');
expect(expr).to.be.a(ol.expression.Logical); expect(expr).to.be.a(ol.expr.Logical);
expect(expr.evaluate({foo: true, bar: true})).to.be(true); expect(expr.evaluate({foo: true, bar: true})).to.be(true);
expect(expr.evaluate({foo: true, bar: false})).to.be(true); expect(expr.evaluate({foo: true, bar: false})).to.be(true);
expect(expr.evaluate({foo: false, bar: true})).to.be(true); expect(expr.evaluate({foo: false, bar: true})).to.be(true);
@@ -484,8 +484,8 @@ describe('ol.expression.parse()', function() {
}); });
it('consumes space as expected with ||', function() { it('consumes space as expected with ||', function() {
var expr = ol.expression.parse(' foo || bar '); var expr = ol.expr.parse(' foo || bar ');
expect(expr).to.be.a(ol.expression.Logical); expect(expr).to.be.a(ol.expr.Logical);
expect(expr.evaluate({foo: true, bar: true})).to.be(true); expect(expr.evaluate({foo: true, bar: true})).to.be(true);
expect(expr.evaluate({foo: true, bar: false})).to.be(true); expect(expr.evaluate({foo: true, bar: false})).to.be(true);
expect(expr.evaluate({foo: false, bar: true})).to.be(true); expect(expr.evaluate({foo: false, bar: true})).to.be(true);
@@ -494,9 +494,9 @@ describe('ol.expression.parse()', function() {
it('throws for invalid spacing with ||', function() { it('throws for invalid spacing with ||', function() {
expect(function() { expect(function() {
ol.expression.parse('true | | false'); ol.expr.parse('true | | false');
}).throwException(function(err) { }).throwException(function(err) {
expect(err).to.be.an(ol.expression.UnexpectedToken); expect(err).to.be.an(ol.expr.UnexpectedToken);
var token = err.token; var token = err.token;
expect(token.value).to.be('|'); expect(token.value).to.be('|');
expect(token.index).to.be(5); expect(token.index).to.be(5);
@@ -522,10 +522,10 @@ describe('ol.expression.parse()', function() {
}); });
describe('ol.expression.lib', function() { describe('ol.expr.lib', function() {
var parse = ol.expression.parse; var parse = ol.expr.parse;
var evaluate = ol.expression.evaluateFeature; var evaluate = ol.expr.evaluateFeature;
describe('extent()', function() { describe('extent()', function() {
@@ -611,48 +611,50 @@ describe('ol.expression.lib', function() {
}); });
describe('ol.expression.register()', function() { describe('ol.expr.register()', function() {
var spy; var spy;
beforeEach(function() { beforeEach(function() {
spy = sinon.spy(); spy = sinon.spy();
}); });
it('registers custom functions in ol.expression.lib', function() { it('registers custom functions in ol.expr.lib', function() {
ol.expression.register('someFunc', spy); ol.expr.register('someFunc', spy);
expect(ol.expression.lib.someFunc).to.be(spy); expect(ol.expr.lib.someFunc).to.be(spy);
}); });
it('allows custom functions to be called', function() { it('allows custom functions to be called', function() {
ol.expression.register('myFunc', spy); ol.expr.register('myFunc', spy);
var expr = ol.expression.parse('myFunc(42)'); var expr = ol.expr.parse('myFunc(42)');
expr.evaluate(null, ol.expression.lib); expr.evaluate(null, ol.expr.lib);
expect(spy.calledOnce); expect(spy.calledOnce);
expect(spy.calledWithExactly(42)); expect(spy.calledWithExactly(42));
}); });
it('allows custom functions to be called with identifiers', function() { it('allows custom functions to be called with identifiers', function() {
ol.expression.register('myFunc', spy); ol.expr.register('myFunc', spy);
var expr = ol.expression.parse('myFunc(foo, 42)'); var expr = ol.expr.parse('myFunc(foo, 42)');
expr.evaluate({foo: 'bar'}, ol.expression.lib); expr.evaluate({foo: 'bar'}, ol.expr.lib);
expect(spy.calledOnce); expect(spy.calledOnce);
expect(spy.calledWithExactly('bar', 42)); expect(spy.calledWithExactly('bar', 42));
}); });
it('allows custom functions to be called with custom this obj', function() { it('allows custom functions to be called with custom this obj', function() {
ol.expression.register('myFunc', spy); ol.expr.register('myFunc', spy);
var expr = ol.expression.parse('myFunc(foo, 42)'); var expr = ol.expr.parse('myFunc(foo, 42)');
var that = {}; var that = {};
expr.evaluate({foo: 'bar'}, ol.expression.lib, that); expr.evaluate({foo: 'bar'}, ol.expr.lib, that);
expect(spy.calledOnce); expect(spy.calledOnce);
expect(spy.calledWithExactly('bar', 42)); expect(spy.calledWithExactly('bar', 42));
expect(spy.calledOn(that)); expect(spy.calledOn(that));
}); });
it('allows overriding existing ol.expression.lib functions', function() { it('allows overriding existing ol.expr.lib functions', function() {
expect(ol.expression.lib.extent).not.to.be(spy); var orig = ol.expr.lib.extent;
ol.expression.register('extent', spy); expect(orig).not.to.be(spy);
expect(ol.expression.lib.extent).to.be(spy); ol.expr.register('extent', spy);
expect(ol.expr.lib.extent).to.be(spy);
ol.expr.lib.extent = orig;
}); });
}); });
@@ -660,18 +662,18 @@ describe('ol.expression.register()', function() {
goog.require('ol.Feature'); goog.require('ol.Feature');
goog.require('ol.expression'); goog.require('ol.expr');
goog.require('ol.expression.Call'); goog.require('ol.expr.Call');
goog.require('ol.expression.Comparison'); goog.require('ol.expr.Comparison');
goog.require('ol.expression.Expression'); goog.require('ol.expr.Expression');
goog.require('ol.expression.Identifier'); goog.require('ol.expr.Identifier');
goog.require('ol.expression.Literal'); goog.require('ol.expr.Literal');
goog.require('ol.expression.Logical'); goog.require('ol.expr.Logical');
goog.require('ol.expression.Math'); goog.require('ol.expr.Math');
goog.require('ol.expression.Member'); goog.require('ol.expr.Member');
goog.require('ol.expression.Not'); goog.require('ol.expr.Not');
goog.require('ol.expression.TokenType'); goog.require('ol.expr.TokenType');
goog.require('ol.expression.UnexpectedToken'); goog.require('ol.expr.UnexpectedToken');
goog.require('ol.geom.LineString'); goog.require('ol.geom.LineString');
goog.require('ol.geom.Point'); goog.require('ol.geom.Point');
goog.require('ol.geom.Polygon'); goog.require('ol.geom.Polygon');

638
test/spec/ol/expr/expressions.test.js Normal file
View File

@@ -0,0 +1,638 @@
goog.provide('ol.test.expression.Expression');
describe('ol.expr.Call', function() {
describe('constructor', function() {
it('creates a new expression', function() {
var expr = new ol.expr.Call(
new ol.expr.Identifier('sqrt'),
[new ol.expr.Literal(42)]);
expect(expr).to.be.a(ol.expr.Expression);
expect(expr).to.be.a(ol.expr.Call);
});
});
describe('#evaluate()', function() {
var fns = {
sqrt: function(value) {
return Math.sqrt(value);
},
strConcat: function() {
return Array.prototype.join.call(arguments, '');
},
discouraged: function() {
return this.message;
}
};
it('calls method on scope with literal args', function() {
var expr = new ol.expr.Call(
new ol.expr.Identifier('sqrt'),
[new ol.expr.Literal(42)]);
expect(expr.evaluate(fns)).to.be(Math.sqrt(42));
});
it('accepts a separate scope for functions', function() {
var expr = new ol.expr.Call(
new ol.expr.Identifier('sqrt'),
[new ol.expr.Identifier('foo')]);
expect(expr.evaluate({foo: 42}, fns)).to.be(Math.sqrt(42));
});
it('accepts multiple expression arguments', function() {
var expr = new ol.expr.Call(
new ol.expr.Identifier('strConcat'),
[
new ol.expr.Identifier('foo'),
new ol.expr.Literal(' comes after '),
new ol.expr.Math(
ol.expr.MathOp.SUBTRACT,
new ol.expr.Identifier('foo'),
new ol.expr.Literal(1))
]);
expect(expr.evaluate({foo: 42}, fns)).to.be('42 comes after 41');
});
it('accepts optional this arg', function() {
var expr = new ol.expr.Call(
new ol.expr.Identifier('discouraged'), []);
var thisArg = {
message: 'avoid this'
};
expect(expr.evaluate(fns, null, thisArg)).to.be('avoid this');
});
});
var callee = new ol.expr.Identifier('sqrt');
var args = [new ol.expr.Literal(42)];
var expr = new ol.expr.Call(callee, args);
describe('#getArgs()', function() {
it('gets the callee expression', function() {
expect(expr.getArgs()).to.be(args);
});
});
describe('#getCallee()', function() {
it('gets the callee expression', function() {
expect(expr.getCallee()).to.be(callee);
});
});
});
describe('ol.expr.Comparison', function() {
describe('constructor', function() {
it('creates a new expression', function() {
var expr = new ol.expr.Comparison(
ol.expr.ComparisonOp.EQ,
new ol.expr.Identifier('foo'),
new ol.expr.Literal(42));
expect(expr).to.be.a(ol.expr.Expression);
expect(expr).to.be.a(ol.expr.Comparison);
});
});
describe('#evaluate()', function() {
it('compares with ==', function() {
var expr = new ol.expr.Comparison(
ol.expr.ComparisonOp.EQ,
new ol.expr.Identifier('foo'),
new ol.expr.Literal(42));
expect(expr.evaluate({foo: 42})).to.be(true);
expect(expr.evaluate({foo: '42'})).to.be(true);
expect(expr.evaluate({foo: true})).to.be(false);
expect(expr.evaluate({bar: true})).to.be(false);
});
it('compares with !=', function() {
var expr = new ol.expr.Comparison(
ol.expr.ComparisonOp.NEQ,
new ol.expr.Identifier('foo'),
new ol.expr.Literal(42));
expect(expr.evaluate({foo: 42})).to.be(false);
expect(expr.evaluate({foo: '42'})).to.be(false);
expect(expr.evaluate({foo: true})).to.be(true);
expect(expr.evaluate({bar: true})).to.be(true);
});
it('compares with ===', function() {
var expr = new ol.expr.Comparison(
ol.expr.ComparisonOp.STRICT_EQ,
new ol.expr.Identifier('foo'),
new ol.expr.Literal(42));
expect(expr.evaluate({foo: 42})).to.be(true);
expect(expr.evaluate({foo: '42'})).to.be(false);
expect(expr.evaluate({foo: true})).to.be(false);
expect(expr.evaluate({bar: true})).to.be(false);
});
it('compares with !==', function() {
var expr = new ol.expr.Comparison(
ol.expr.ComparisonOp.STRICT_NEQ,
new ol.expr.Identifier('foo'),
new ol.expr.Literal(42));
expect(expr.evaluate({foo: 42})).to.be(false);
expect(expr.evaluate({foo: '42'})).to.be(true);
expect(expr.evaluate({foo: true})).to.be(true);
expect(expr.evaluate({bar: true})).to.be(true);
});
it('compares with >', function() {
var expr = new ol.expr.Comparison(
ol.expr.ComparisonOp.GT,
new ol.expr.Identifier('foo'),
new ol.expr.Literal(42));
expect(expr.evaluate({foo: 42})).to.be(false);
expect(expr.evaluate({foo: 41})).to.be(false);
expect(expr.evaluate({foo: 43})).to.be(true);
});
it('compares with <', function() {
var expr = new ol.expr.Comparison(
ol.expr.ComparisonOp.LT,
new ol.expr.Identifier('foo'),
new ol.expr.Literal(42));
expect(expr.evaluate({foo: 42})).to.be(false);
expect(expr.evaluate({foo: 41})).to.be(true);
expect(expr.evaluate({foo: 43})).to.be(false);
});
it('compares with >=', function() {
var expr = new ol.expr.Comparison(
ol.expr.ComparisonOp.GTE,
new ol.expr.Identifier('foo'),
new ol.expr.Literal(42));
expect(expr.evaluate({foo: 42})).to.be(true);
expect(expr.evaluate({foo: 41})).to.be(false);
expect(expr.evaluate({foo: 43})).to.be(true);
});
it('compares with <=', function() {
var expr = new ol.expr.Comparison(
ol.expr.ComparisonOp.LTE,
new ol.expr.Identifier('foo'),
new ol.expr.Literal(42));
expect(expr.evaluate({foo: 42})).to.be(true);
expect(expr.evaluate({foo: 41})).to.be(true);
expect(expr.evaluate({foo: 43})).to.be(false);
});
});
describe('#isValidOp()', function() {
it('determines if a string is a valid operator', function() {
expect(ol.expr.Comparison.isValidOp('<')).to.be(true);
expect(ol.expr.Comparison.isValidOp('<')).to.be(true);
expect(ol.expr.Comparison.isValidOp('<=')).to.be(true);
expect(ol.expr.Comparison.isValidOp('<=')).to.be(true);
expect(ol.expr.Comparison.isValidOp('==')).to.be(true);
expect(ol.expr.Comparison.isValidOp('!=')).to.be(true);
expect(ol.expr.Comparison.isValidOp('===')).to.be(true);
expect(ol.expr.Comparison.isValidOp('!==')).to.be(true);
expect(ol.expr.Comparison.isValidOp('')).to.be(false);
expect(ol.expr.Comparison.isValidOp('+')).to.be(false);
expect(ol.expr.Comparison.isValidOp('-')).to.be(false);
expect(ol.expr.Comparison.isValidOp('&&')).to.be(false);
});
});
var op = ol.expr.ComparisonOp.LTE;
var left = new ol.expr.Identifier('foo');
var right = new ol.expr.Literal(42);
var expr = new ol.expr.Comparison(op, left, right);
describe('#getOperator()', function() {
it('gets the operator', function() {
expect(expr.getOperator()).to.be(op);
});
});
describe('#getLeft()', function() {
it('gets the left expression', function() {
expect(expr.getLeft()).to.be(left);
});
});
describe('#getRight()', function() {
it('gets the right expression', function() {
expect(expr.getRight()).to.be(right);
});
});
});
describe('ol.expr.Identifier', function() {
describe('constructor', function() {
it('creates a new expression', function() {
var expr = new ol.expr.Identifier('foo');
expect(expr).to.be.a(ol.expr.Expression);
expect(expr).to.be.a(ol.expr.Identifier);
});
});
describe('#evaluate()', function() {
it('returns a number from the scope', function() {
var expr = new ol.expr.Identifier('foo');
expect(expr.evaluate({foo: 42})).to.be(42);
});
it('returns a string from the scope', function() {
var expr = new ol.expr.Identifier('foo');
expect(expr.evaluate({foo: 'chicken'})).to.be('chicken');
});
it('returns a boolean from the scope', function() {
var expr = new ol.expr.Identifier('bar');
expect(expr.evaluate({bar: false})).to.be(false);
expect(expr.evaluate({bar: true})).to.be(true);
});
it('returns a null from the scope', function() {
var expr = new ol.expr.Identifier('nada');
expect(expr.evaluate({nada: null})).to.be(null);
});
it('works for unicode identifiers', function() {
var expr = new ol.expr.Identifier('\u03c0');
expect(expr.evaluate({'\u03c0': Math.PI})).to.be(Math.PI);
});
});
describe('#getName()', function() {
var expr = new ol.expr.Identifier('asdf');
expect(expr.getName()).to.be('asdf');
});
});
describe('ol.expr.Literal', function() {
describe('constructor', function() {
it('creates a new expression', function() {
var expr = new ol.expr.Literal(true);
expect(expr).to.be.a(ol.expr.Expression);
expect(expr).to.be.a(ol.expr.Literal);
});
});
describe('#evaluate()', function() {
it('works for numeric literal', function() {
var expr = new ol.expr.Literal(42e-11);
expect(expr.evaluate()).to.be(4.2e-10);
});
it('works for string literal', function() {
var expr = new ol.expr.Literal('asdf');
expect(expr.evaluate()).to.be('asdf');
});
it('works for boolean literal', function() {
var expr = new ol.expr.Literal(true);
expect(expr.evaluate()).to.be(true);
});
it('works for null literal', function() {
var expr = new ol.expr.Literal(null);
expect(expr.evaluate()).to.be(null);
});
});
describe('#getValue()', function() {
var expr = new ol.expr.Literal('asdf');
expect(expr.getValue()).to.be('asdf');
});
});
describe('ol.expr.Logical', function() {
describe('constructor', function() {
it('creates a new expression', function() {
var expr = new ol.expr.Logical(
ol.expr.LogicalOp.OR,
new ol.expr.Identifier('foo'),
new ol.expr.Identifier('bar'));
expect(expr).to.be.a(ol.expr.Expression);
expect(expr).to.be.a(ol.expr.Logical);
});
});
describe('#evaluate()', function() {
it('applies || to resolved identifiers', function() {
var expr = new ol.expr.Logical(
ol.expr.LogicalOp.OR,
new ol.expr.Identifier('foo'),
new ol.expr.Identifier('bar'));
expect(expr.evaluate({foo: true, bar: true})).to.be(true);
expect(expr.evaluate({foo: true, bar: false})).to.be(true);
expect(expr.evaluate({foo: false, bar: true})).to.be(true);
expect(expr.evaluate({foo: false, bar: false})).to.be(false);
});
it('applies && to resolved identifiers', function() {
var expr = new ol.expr.Logical(
ol.expr.LogicalOp.AND,
new ol.expr.Identifier('foo'),
new ol.expr.Identifier('bar'));
expect(expr.evaluate({foo: true, bar: true})).to.be(true);
expect(expr.evaluate({foo: true, bar: false})).to.be(false);
expect(expr.evaluate({foo: false, bar: true})).to.be(false);
expect(expr.evaluate({foo: false, bar: false})).to.be(false);
});
});
describe('#isValidOp()', function() {
it('determines if a string is a valid operator', function() {
expect(ol.expr.Logical.isValidOp('||')).to.be(true);
expect(ol.expr.Logical.isValidOp('&&')).to.be(true);
expect(ol.expr.Logical.isValidOp('')).to.be(false);
expect(ol.expr.Logical.isValidOp('+')).to.be(false);
expect(ol.expr.Logical.isValidOp('<')).to.be(false);
expect(ol.expr.Logical.isValidOp('|')).to.be(false);
});
});
var op = ol.expr.LogicalOp.AND;
var left = new ol.expr.Identifier('foo');
var right = new ol.expr.Literal(false);
var expr = new ol.expr.Logical(op, left, right);
describe('#getOperator()', function() {
it('gets the operator', function() {
expect(expr.getOperator()).to.be(op);
});
});
describe('#getLeft()', function() {
it('gets the left expression', function() {
expect(expr.getLeft()).to.be(left);
});
});
describe('#getRight()', function() {
it('gets the right expression', function() {
expect(expr.getRight()).to.be(right);
});
});
});
describe('ol.expr.Math', function() {
describe('constructor', function() {
it('creates a new expression', function() {
var expr = new ol.expr.Math(
ol.expr.MathOp.ADD,
new ol.expr.Literal(40),
new ol.expr.Literal(2));
expect(expr).to.be.a(ol.expr.Expression);
expect(expr).to.be.a(ol.expr.Math);
});
});
describe('#evaluate()', function() {
it('does + with numeric literal', function() {
var expr = new ol.expr.Math(
ol.expr.MathOp.ADD,
new ol.expr.Literal(40),
new ol.expr.Literal(2));
expect(expr.evaluate()).to.be(42);
});
it('does + with string literal (note: subject to change)', function() {
var expr = new ol.expr.Math(
ol.expr.MathOp.ADD,
new ol.expr.Literal('foo'),
new ol.expr.Literal('bar'));
expect(expr.evaluate()).to.be('foobar');
});
it('does + with identifiers', function() {
var expr = new ol.expr.Math(
ol.expr.MathOp.ADD,
new ol.expr.Identifier('foo'),
new ol.expr.Identifier('bar'));
expect(expr.evaluate({foo: 40, bar: 2})).to.be(42);
});
it('does - with identifiers', function() {
var expr = new ol.expr.Math(
ol.expr.MathOp.SUBTRACT,
new ol.expr.Identifier('foo'),
new ol.expr.Literal(2));
expect(expr.evaluate({foo: 40})).to.be(38);
});
it('casts to number with - (note: this may throw later)', function() {
var expr = new ol.expr.Math(
ol.expr.MathOp.SUBTRACT,
new ol.expr.Identifier('foo'),
new ol.expr.Literal(2));
expect(expr.evaluate({foo: '40'})).to.be(38);
});
it('does * with identifiers', function() {
var expr = new ol.expr.Math(
ol.expr.MathOp.MULTIPLY,
new ol.expr.Literal(2),
new ol.expr.Identifier('foo'));
expect(expr.evaluate({foo: 21})).to.be(42);
});
it('casts to number with * (note: this may throw later)', function() {
var expr = new ol.expr.Math(
ol.expr.MathOp.MULTIPLY,
new ol.expr.Identifier('foo'),
new ol.expr.Literal(2));
expect(expr.evaluate({foo: '21'})).to.be(42);
});
it('does % with identifiers', function() {
var expr = new ol.expr.Math(
ol.expr.MathOp.MOD,
new ol.expr.Literal(97),
new ol.expr.Identifier('foo'));
expect(expr.evaluate({foo: 55})).to.be(42);
});
it('casts to number with % (note: this may throw later)', function() {
var expr = new ol.expr.Math(
ol.expr.MathOp.MOD,
new ol.expr.Identifier('foo'),
new ol.expr.Literal(100));
expect(expr.evaluate({foo: '150'})).to.be(50);
});
});
describe('#isValidOp()', function() {
it('determines if a string is a valid operator', function() {
expect(ol.expr.Math.isValidOp('+')).to.be(true);
expect(ol.expr.Math.isValidOp('-')).to.be(true);
expect(ol.expr.Math.isValidOp('*')).to.be(true);
expect(ol.expr.Math.isValidOp('/')).to.be(true);
expect(ol.expr.Math.isValidOp('%')).to.be(true);
expect(ol.expr.Math.isValidOp('')).to.be(false);
expect(ol.expr.Math.isValidOp('|')).to.be(false);
expect(ol.expr.Math.isValidOp('&')).to.be(false);
expect(ol.expr.Math.isValidOp('<')).to.be(false);
expect(ol.expr.Math.isValidOp('||')).to.be(false);
expect(ol.expr.Math.isValidOp('.')).to.be(false);
});
});
var op = ol.expr.MathOp.MOD;
var left = new ol.expr.Identifier('foo');
var right = new ol.expr.Literal(20);
var expr = new ol.expr.Math(op, left, right);
describe('#getOperator()', function() {
it('gets the operator', function() {
expect(expr.getOperator()).to.be(op);
});
});
describe('#getLeft()', function() {
it('gets the left expression', function() {
expect(expr.getLeft()).to.be(left);
});
});
describe('#getRight()', function() {
it('gets the right expression', function() {
expect(expr.getRight()).to.be(right);
});
});
});
describe('ol.expr.Member', function() {
describe('constructor', function() {
it('creates a new expression', function() {
var expr = new ol.expr.Member(
new ol.expr.Identifier('foo'),
new ol.expr.Identifier('bar'));
expect(expr).to.be.a(ol.expr.Expression);
expect(expr).to.be.a(ol.expr.Member);
});
});
describe('#evaluate()', function() {
it('accesses an object property', function() {
var expr = new ol.expr.Member(
new ol.expr.Identifier('foo'),
new ol.expr.Identifier('bar'));
var scope = {foo: {bar: 42}};
expect(expr.evaluate(scope)).to.be(42);
});
});
var object = new ol.expr.Identifier('foo');
var property = new ol.expr.Identifier('bar');
var expr = new ol.expr.Member(object, property);
describe('#getObject()', function() {
expect(expr.getObject()).to.be(object);
});
describe('#getProperty()', function() {
expect(expr.getProperty()).to.be(property);
});
});
describe('ol.expr.Not', function() {
describe('constructor', function() {
it('creates a new expression', function() {
var expr = new ol.expr.Not(
new ol.expr.Literal(true));
expect(expr).to.be.a(ol.expr.Expression);
expect(expr).to.be.a(ol.expr.Not);
});
});
describe('#evaluate()', function() {
it('returns the logical complement', function() {
var expr = new ol.expr.Not(new ol.expr.Literal(true));
expect(expr.evaluate()).to.be(false);
expr = new ol.expr.Not(new ol.expr.Literal(false));
expect(expr.evaluate()).to.be(true);
});
it('negates a truthy string', function() {
var expr = new ol.expr.Not(new ol.expr.Literal('asdf'));
expect(expr.evaluate()).to.be(false);
});
it('negates a falsy string', function() {
var expr = new ol.expr.Not(new ol.expr.Literal(''));
expect(expr.evaluate()).to.be(true);
});
it('negates a truthy number', function() {
var expr = new ol.expr.Not(new ol.expr.Literal(42));
expect(expr.evaluate()).to.be(false);
});
it('negates a falsy number', function() {
var expr = new ol.expr.Not(new ol.expr.Literal(NaN));
expect(expr.evaluate()).to.be(true);
});
});
describe('#getArgument()', function() {
var argument = new ol.expr.Literal(true);
var expr = new ol.expr.Not(argument);
expect(expr.getArgument()).to.be(argument);
});
});
goog.require('ol.expr.Call');
goog.require('ol.expr.Comparison');
goog.require('ol.expr.ComparisonOp');
goog.require('ol.expr.Expression');
goog.require('ol.expr.Identifier');
goog.require('ol.expr.Literal');
goog.require('ol.expr.Logical');
goog.require('ol.expr.LogicalOp');
goog.require('ol.expr.Math');
goog.require('ol.expr.MathOp');
goog.require('ol.expr.Member');
goog.require('ol.expr.Not');

166
test/spec/ol/expression/lexer.test.js → test/spec/ol/expr/lexer.test.js
View File

@@ -1,11 +1,11 @@
goog.provide('ol.test.expression.Lexer'); goog.provide('ol.test.expression.Lexer');
describe('ol.expression.Lexer', function() { describe('ol.expr.Lexer', function() {
describe('constructor', function() { describe('constructor', function() {
it('creates a new lexer', function() { it('creates a new lexer', function() {
var lexer = new ol.expression.Lexer('foo'); var lexer = new ol.expr.Lexer('foo');
expect(lexer).to.be.a(ol.expression.Lexer); expect(lexer).to.be.a(ol.expr.Lexer);
}); });
}); });
@@ -13,30 +13,30 @@ describe('ol.expression.Lexer', function() {
it('returns one token at a time', function() { it('returns one token at a time', function() {
var source = 'foo === "bar"'; var source = 'foo === "bar"';
var lexer = new ol.expression.Lexer(source); var lexer = new ol.expr.Lexer(source);
// scan first token // scan first token
var token = lexer.next(); var token = lexer.next();
expect(token.type).to.be(ol.expression.TokenType.IDENTIFIER); expect(token.type).to.be(ol.expr.TokenType.IDENTIFIER);
expect(token.value).to.be('foo'); expect(token.value).to.be('foo');
// scan second token // scan second token
token = lexer.next(); token = lexer.next();
expect(token.type).to.be(ol.expression.TokenType.PUNCTUATOR); expect(token.type).to.be(ol.expr.TokenType.PUNCTUATOR);
expect(token.value).to.be('==='); expect(token.value).to.be('===');
// scan third token // scan third token
token = lexer.next(); token = lexer.next();
expect(token.type).to.be(ol.expression.TokenType.STRING_LITERAL); expect(token.type).to.be(ol.expr.TokenType.STRING_LITERAL);
expect(token.value).to.be('bar'); expect(token.value).to.be('bar');
// scan again // scan again
token = lexer.next(); token = lexer.next();
expect(token.type).to.be(ol.expression.TokenType.EOF); expect(token.type).to.be(ol.expr.TokenType.EOF);
// and again // and again
token = lexer.next(); token = lexer.next();
expect(token.type).to.be(ol.expression.TokenType.EOF); expect(token.type).to.be(ol.expr.TokenType.EOF);
}); });
}); });
@@ -45,45 +45,45 @@ describe('ol.expression.Lexer', function() {
var lexer; var lexer;
beforeEach(function() { beforeEach(function() {
lexer = new ol.expression.Lexer('foo > 42 && bar == "chicken"'); lexer = new ol.expr.Lexer('foo > 42 && bar == "chicken"');
}); });
it('looks ahead without consuming token', function() { it('looks ahead without consuming token', function() {
var token = lexer.peek(); var token = lexer.peek();
expect(token.type).to.be(ol.expression.TokenType.IDENTIFIER); expect(token.type).to.be(ol.expr.TokenType.IDENTIFIER);
expect(token.value).to.be('foo'); expect(token.value).to.be('foo');
token = lexer.next(); token = lexer.next();
expect(token.type).to.be(ol.expression.TokenType.IDENTIFIER); expect(token.type).to.be(ol.expr.TokenType.IDENTIFIER);
expect(token.value).to.be('foo'); expect(token.value).to.be('foo');
}); });
it('works after a couple scans', function() { it('works after a couple scans', function() {
var token = lexer.next(); var token = lexer.next();
expect(token.type).to.be(ol.expression.TokenType.IDENTIFIER); expect(token.type).to.be(ol.expr.TokenType.IDENTIFIER);
expect(token.value).to.be('foo'); expect(token.value).to.be('foo');
token = lexer.next(); token = lexer.next();
expect(token.type).to.be(ol.expression.TokenType.PUNCTUATOR); expect(token.type).to.be(ol.expr.TokenType.PUNCTUATOR);
expect(token.value).to.be('>'); expect(token.value).to.be('>');
token = lexer.peek(); token = lexer.peek();
expect(token.type).to.be(ol.expression.TokenType.NUMERIC_LITERAL); expect(token.type).to.be(ol.expr.TokenType.NUMERIC_LITERAL);
expect(token.value).to.be(42); expect(token.value).to.be(42);
token = lexer.next(); token = lexer.next();
expect(token.type).to.be(ol.expression.TokenType.NUMERIC_LITERAL); expect(token.type).to.be(ol.expr.TokenType.NUMERIC_LITERAL);
expect(token.value).to.be(42); expect(token.value).to.be(42);
}); });
it('returns the same thing when called multiple times', function() { it('returns the same thing when called multiple times', function() {
var token = lexer.peek(); var token = lexer.peek();
expect(token.type).to.be(ol.expression.TokenType.IDENTIFIER); expect(token.type).to.be(ol.expr.TokenType.IDENTIFIER);
expect(token.value).to.be('foo'); expect(token.value).to.be('foo');
for (var i = 0; i < 10; ++i) { for (var i = 0; i < 10; ++i) {
token = lexer.peek(); token = lexer.peek();
expect(token.type).to.be(ol.expression.TokenType.IDENTIFIER); expect(token.type).to.be(ol.expr.TokenType.IDENTIFIER);
expect(token.value).to.be('foo'); expect(token.value).to.be('foo');
} }
}); });
@@ -94,11 +94,11 @@ describe('ol.expression.Lexer', function() {
describe('#scanIdentifier_()', function() { describe('#scanIdentifier_()', function() {
function scan(source, part) { function scan(source, part) {
var lexer = new ol.expression.Lexer(source); var lexer = new ol.expr.Lexer(source);
var token = lexer.scanIdentifier_(lexer.getCurrentCharCode_()); var token = lexer.scanIdentifier_(lexer.getCurrentCharCode_());
if (!part) { if (!part) {
expect(token.index).to.be(0); expect(token.index).to.be(0);
expect(lexer.peek().type).to.be(ol.expression.TokenType.EOF); expect(lexer.peek().type).to.be(ol.expr.TokenType.EOF);
} }
return token; return token;
} }
@@ -106,61 +106,61 @@ describe('ol.expression.Lexer', function() {
it('works for short identifiers', function() { it('works for short identifiers', function() {
var token = scan('a'); var token = scan('a');
expect(token.value).to.be('a'); expect(token.value).to.be('a');
expect(token.type).to.be(ol.expression.TokenType.IDENTIFIER); expect(token.type).to.be(ol.expr.TokenType.IDENTIFIER);
}); });
it('works for longer identifiers', function() { it('works for longer identifiers', function() {
var token = scan('foo'); var token = scan('foo');
expect(token.value).to.be('foo'); expect(token.value).to.be('foo');
expect(token.type).to.be(ol.expression.TokenType.IDENTIFIER); expect(token.type).to.be(ol.expr.TokenType.IDENTIFIER);
}); });
it('works for $ anywhere', function() { it('works for $ anywhere', function() {
var token = scan('$foo$bar$'); var token = scan('$foo$bar$');
expect(token.value).to.be('$foo$bar$'); expect(token.value).to.be('$foo$bar$');
expect(token.type).to.be(ol.expression.TokenType.IDENTIFIER); expect(token.type).to.be(ol.expr.TokenType.IDENTIFIER);
}); });
it('works for _ anywhere', function() { it('works for _ anywhere', function() {
var token = scan('_foo_bar_'); var token = scan('_foo_bar_');
expect(token.value).to.be('_foo_bar_'); expect(token.value).to.be('_foo_bar_');
expect(token.type).to.be(ol.expression.TokenType.IDENTIFIER); expect(token.type).to.be(ol.expr.TokenType.IDENTIFIER);
}); });
it('works for keywords', function() { it('works for keywords', function() {
var token = scan('delete'); var token = scan('delete');
expect(token.value).to.be('delete'); expect(token.value).to.be('delete');
expect(token.type).to.be(ol.expression.TokenType.KEYWORD); expect(token.type).to.be(ol.expr.TokenType.KEYWORD);
}); });
it('works for null', function() { it('works for null', function() {
var token = scan('null'); var token = scan('null');
expect(token.value).to.be('null'); expect(token.value).to.be('null');
expect(token.type).to.be(ol.expression.TokenType.NULL_LITERAL); expect(token.type).to.be(ol.expr.TokenType.NULL_LITERAL);
}); });
it('works for boolean true', function() { it('works for boolean true', function() {
var token = scan('true'); var token = scan('true');
expect(token.value).to.be('true'); expect(token.value).to.be('true');
expect(token.type).to.be(ol.expression.TokenType.BOOLEAN_LITERAL); expect(token.type).to.be(ol.expr.TokenType.BOOLEAN_LITERAL);
}); });
it('works for boolean false', function() { it('works for boolean false', function() {
var token = scan('false'); var token = scan('false');
expect(token.value).to.be('false'); expect(token.value).to.be('false');
expect(token.type).to.be(ol.expression.TokenType.BOOLEAN_LITERAL); expect(token.type).to.be(ol.expr.TokenType.BOOLEAN_LITERAL);
}); });
it('works with unicode escape sequences', function() { it('works with unicode escape sequences', function() {
var token = scan('\u006f\u006c\u0033'); var token = scan('\u006f\u006c\u0033');
expect(token.value).to.be('ol3'); expect(token.value).to.be('ol3');
expect(token.type).to.be(ol.expression.TokenType.IDENTIFIER); expect(token.type).to.be(ol.expr.TokenType.IDENTIFIER);
}); });
it('works with hex escape sequences', function() { it('works with hex escape sequences', function() {
var token = scan('\x6f\x6c\x33'); var token = scan('\x6f\x6c\x33');
expect(token.value).to.be('ol3'); expect(token.value).to.be('ol3');
expect(token.type).to.be(ol.expression.TokenType.IDENTIFIER); expect(token.type).to.be(ol.expr.TokenType.IDENTIFIER);
}); });
it('throws for identifiers starting with a number', function() { it('throws for identifiers starting with a number', function() {
@@ -178,7 +178,7 @@ describe('ol.expression.Lexer', function() {
it('only scans valid identifier part', function() { it('only scans valid identifier part', function() {
var token = scan('foo>bar', true); var token = scan('foo>bar', true);
expect(token.value).to.be('foo'); expect(token.value).to.be('foo');
expect(token.type).to.be(ol.expression.TokenType.IDENTIFIER); expect(token.type).to.be(ol.expr.TokenType.IDENTIFIER);
}); });
}); });
@@ -186,24 +186,24 @@ describe('ol.expression.Lexer', function() {
describe('#scanNumericLiteral_()', function() { describe('#scanNumericLiteral_()', function() {
function scan(source) { function scan(source) {
var lexer = new ol.expression.Lexer(source); var lexer = new ol.expr.Lexer(source);
var token = lexer.scanNumericLiteral_(lexer.getCurrentCharCode_()); var token = lexer.scanNumericLiteral_(lexer.getCurrentCharCode_());
expect(token.index).to.be(0); expect(token.index).to.be(0);
expect(lexer.peek().type).to.be(ol.expression.TokenType.EOF); expect(lexer.peek().type).to.be(ol.expr.TokenType.EOF);
return token; return token;
} }
it('works for integers', function() { it('works for integers', function() {
var token = scan('123'); var token = scan('123');
expect(token.value).to.be(123); expect(token.value).to.be(123);
expect(token.type).to.be(ol.expression.TokenType.NUMERIC_LITERAL); expect(token.type).to.be(ol.expr.TokenType.NUMERIC_LITERAL);
}); });
it('throws for bogus integer', function() { it('throws for bogus integer', function() {
expect(function() { expect(function() {
scan('123z'); scan('123z');
}).throwException(function(err) { }).throwException(function(err) {
expect(err).to.be.an(ol.expression.UnexpectedToken); expect(err).to.be.an(ol.expr.UnexpectedToken);
var token = err.token; var token = err.token;
expect(token.value).to.be('z'); expect(token.value).to.be('z');
expect(token.index).to.be(3); expect(token.index).to.be(3);
@@ -213,14 +213,14 @@ describe('ol.expression.Lexer', function() {
it('works for float', function() { it('works for float', function() {
var token = scan('123.456'); var token = scan('123.456');
expect(token.value).to.be(123.456); expect(token.value).to.be(123.456);
expect(token.type).to.be(ol.expression.TokenType.NUMERIC_LITERAL); expect(token.type).to.be(ol.expr.TokenType.NUMERIC_LITERAL);
}); });
it('throws for bogus float', function() { it('throws for bogus float', function() {
expect(function() { expect(function() {
scan('123.4x4'); scan('123.4x4');
}).throwException(function(err) { }).throwException(function(err) {
expect(err).to.be.an(ol.expression.UnexpectedToken); expect(err).to.be.an(ol.expr.UnexpectedToken);
var token = err.token; var token = err.token;
expect(token.value).to.be('x'); expect(token.value).to.be('x');
expect(token.index).to.be(5); expect(token.index).to.be(5);
@@ -230,26 +230,26 @@ describe('ol.expression.Lexer', function() {
it('works with exponent', function() { it('works with exponent', function() {
var token = scan('1.234e5'); var token = scan('1.234e5');
expect(token.value).to.be(1.234e5); expect(token.value).to.be(1.234e5);
expect(token.type).to.be(ol.expression.TokenType.NUMERIC_LITERAL); expect(token.type).to.be(ol.expr.TokenType.NUMERIC_LITERAL);
}); });
it('works with explicit positive exponent', function() { it('works with explicit positive exponent', function() {
var token = scan('1.234e+5'); var token = scan('1.234e+5');
expect(token.value).to.be(1.234e5); expect(token.value).to.be(1.234e5);
expect(token.type).to.be(ol.expression.TokenType.NUMERIC_LITERAL); expect(token.type).to.be(ol.expr.TokenType.NUMERIC_LITERAL);
}); });
it('works with negative exponent', function() { it('works with negative exponent', function() {
var token = scan('1.234e-5'); var token = scan('1.234e-5');
expect(token.value).to.be(1.234e-5); expect(token.value).to.be(1.234e-5);
expect(token.type).to.be(ol.expression.TokenType.NUMERIC_LITERAL); expect(token.type).to.be(ol.expr.TokenType.NUMERIC_LITERAL);
}); });
it('throws for bogus float', function() { it('throws for bogus float', function() {
expect(function() { expect(function() {
scan('1.234eo4'); scan('1.234eo4');
}).throwException(function(err) { }).throwException(function(err) {
expect(err).to.be.an(ol.expression.UnexpectedToken); expect(err).to.be.an(ol.expr.UnexpectedToken);
var token = err.token; var token = err.token;
expect(token.value).to.be('o'); expect(token.value).to.be('o');
expect(token.index).to.be(6); expect(token.index).to.be(6);
@@ -259,7 +259,7 @@ describe('ol.expression.Lexer', function() {
it('works with octals', function() { it('works with octals', function() {
var token = scan('02322'); var token = scan('02322');
expect(token.value).to.be(1234); expect(token.value).to.be(1234);
expect(token.type).to.be(ol.expression.TokenType.NUMERIC_LITERAL); expect(token.type).to.be(ol.expr.TokenType.NUMERIC_LITERAL);
}); });
it('throws for bogus octal', function() { it('throws for bogus octal', function() {
@@ -267,7 +267,7 @@ describe('ol.expression.Lexer', function() {
expect(function() { expect(function() {
scan('02392'); scan('02392');
}).throwException(function(err) { }).throwException(function(err) {
expect(err).to.be.an(ol.expression.UnexpectedToken); expect(err).to.be.an(ol.expr.UnexpectedToken);
var token = err.token; var token = err.token;
expect(token.value).to.be('9'); expect(token.value).to.be('9');
expect(token.index).to.be(3); expect(token.index).to.be(3);
@@ -277,7 +277,7 @@ describe('ol.expression.Lexer', function() {
it('works with hex', function() { it('works with hex', function() {
var token = scan('0x4d2'); var token = scan('0x4d2');
expect(token.value).to.be(1234); expect(token.value).to.be(1234);
expect(token.type).to.be(ol.expression.TokenType.NUMERIC_LITERAL); expect(token.type).to.be(ol.expr.TokenType.NUMERIC_LITERAL);
}); });
it('throws for bogus hex', function() { it('throws for bogus hex', function() {
@@ -285,7 +285,7 @@ describe('ol.expression.Lexer', function() {
expect(function() { expect(function() {
scan('0x4G'); scan('0x4G');
}).throwException(function(err) { }).throwException(function(err) {
expect(err).to.be.an(ol.expression.UnexpectedToken); expect(err).to.be.an(ol.expr.UnexpectedToken);
var token = err.token; var token = err.token;
expect(token.value).to.be('G'); expect(token.value).to.be('G');
expect(token.index).to.be(3); expect(token.index).to.be(3);
@@ -297,89 +297,89 @@ describe('ol.expression.Lexer', function() {
describe('#scanPunctuator_()', function() { describe('#scanPunctuator_()', function() {
function scan(source) { function scan(source) {
var lexer = new ol.expression.Lexer(source); var lexer = new ol.expr.Lexer(source);
var token = lexer.scanPunctuator_(lexer.getCurrentCharCode_()); var token = lexer.scanPunctuator_(lexer.getCurrentCharCode_());
expect(token.index).to.be(0); expect(token.index).to.be(0);
expect(lexer.peek().type).to.be(ol.expression.TokenType.EOF); expect(lexer.peek().type).to.be(ol.expr.TokenType.EOF);
return token; return token;
} }
it('works for dot', function() { it('works for dot', function() {
var token = scan('.'); var token = scan('.');
expect(token.value).to.be('.'); expect(token.value).to.be('.');
expect(token.type).to.be(ol.expression.TokenType.PUNCTUATOR); expect(token.type).to.be(ol.expr.TokenType.PUNCTUATOR);
}); });
it('works for bang', function() { it('works for bang', function() {
var token = scan('!'); var token = scan('!');
expect(token.value).to.be('!'); expect(token.value).to.be('!');
expect(token.type).to.be(ol.expression.TokenType.PUNCTUATOR); expect(token.type).to.be(ol.expr.TokenType.PUNCTUATOR);
}); });
it('works for double equal', function() { it('works for double equal', function() {
var token = scan('=='); var token = scan('==');
expect(token.value).to.be('=='); expect(token.value).to.be('==');
expect(token.type).to.be(ol.expression.TokenType.PUNCTUATOR); expect(token.type).to.be(ol.expr.TokenType.PUNCTUATOR);
}); });
it('works for triple equal', function() { it('works for triple equal', function() {
var token = scan('==='); var token = scan('===');
expect(token.value).to.be('==='); expect(token.value).to.be('===');
expect(token.type).to.be(ol.expression.TokenType.PUNCTUATOR); expect(token.type).to.be(ol.expr.TokenType.PUNCTUATOR);
}); });
it('works for not double equal', function() { it('works for not double equal', function() {
var token = scan('!='); var token = scan('!=');
expect(token.value).to.be('!='); expect(token.value).to.be('!=');
expect(token.type).to.be(ol.expression.TokenType.PUNCTUATOR); expect(token.type).to.be(ol.expr.TokenType.PUNCTUATOR);
}); });
it('works for not triple equal', function() { it('works for not triple equal', function() {
var token = scan('!=='); var token = scan('!==');
expect(token.value).to.be('!=='); expect(token.value).to.be('!==');
expect(token.type).to.be(ol.expression.TokenType.PUNCTUATOR); expect(token.type).to.be(ol.expr.TokenType.PUNCTUATOR);
}); });
it('works for logical or', function() { it('works for logical or', function() {
var token = scan('||'); var token = scan('||');
expect(token.value).to.be('||'); expect(token.value).to.be('||');
expect(token.type).to.be(ol.expression.TokenType.PUNCTUATOR); expect(token.type).to.be(ol.expr.TokenType.PUNCTUATOR);
}); });
it('works for logical and', function() { it('works for logical and', function() {
var token = scan('&&'); var token = scan('&&');
expect(token.value).to.be('&&'); expect(token.value).to.be('&&');
expect(token.type).to.be(ol.expression.TokenType.PUNCTUATOR); expect(token.type).to.be(ol.expr.TokenType.PUNCTUATOR);
}); });
it('works for plus', function() { it('works for plus', function() {
var token = scan('+'); var token = scan('+');
expect(token.value).to.be('+'); expect(token.value).to.be('+');
expect(token.type).to.be(ol.expression.TokenType.PUNCTUATOR); expect(token.type).to.be(ol.expr.TokenType.PUNCTUATOR);
}); });
it('works for minus', function() { it('works for minus', function() {
var token = scan('-'); var token = scan('-');
expect(token.value).to.be('-'); expect(token.value).to.be('-');
expect(token.type).to.be(ol.expression.TokenType.PUNCTUATOR); expect(token.type).to.be(ol.expr.TokenType.PUNCTUATOR);
}); });
it('works for star', function() { it('works for star', function() {
var token = scan('*'); var token = scan('*');
expect(token.value).to.be('*'); expect(token.value).to.be('*');
expect(token.type).to.be(ol.expression.TokenType.PUNCTUATOR); expect(token.type).to.be(ol.expr.TokenType.PUNCTUATOR);
}); });
it('works for slash', function() { it('works for slash', function() {
var token = scan('/'); var token = scan('/');
expect(token.value).to.be('/'); expect(token.value).to.be('/');
expect(token.type).to.be(ol.expression.TokenType.PUNCTUATOR); expect(token.type).to.be(ol.expr.TokenType.PUNCTUATOR);
}); });
it('works for percent', function() { it('works for percent', function() {
var token = scan('%'); var token = scan('%');
expect(token.value).to.be('%'); expect(token.value).to.be('%');
expect(token.type).to.be(ol.expression.TokenType.PUNCTUATOR); expect(token.type).to.be(ol.expr.TokenType.PUNCTUATOR);
}); });
}); });
@@ -387,62 +387,62 @@ describe('ol.expression.Lexer', function() {
describe('#scanStringLiteral_()', function() { describe('#scanStringLiteral_()', function() {
function scan(source) { function scan(source) {
var lexer = new ol.expression.Lexer(source); var lexer = new ol.expr.Lexer(source);
var token = lexer.scanStringLiteral_(lexer.getCurrentCharCode_()); var token = lexer.scanStringLiteral_(lexer.getCurrentCharCode_());
expect(token.index).to.be(0); expect(token.index).to.be(0);
expect(lexer.peek().type).to.be(ol.expression.TokenType.EOF); expect(lexer.peek().type).to.be(ol.expr.TokenType.EOF);
return token; return token;
} }
it('parses double quoted string', function() { it('parses double quoted string', function() {
var token = scan('"my string"'); var token = scan('"my string"');
expect(token.value).to.be('my string'); expect(token.value).to.be('my string');
expect(token.type).to.be(ol.expression.TokenType.STRING_LITERAL); expect(token.type).to.be(ol.expr.TokenType.STRING_LITERAL);
}); });
it('parses double quoted string with internal single quotes', function() { it('parses double quoted string with internal single quotes', function() {
var token = scan('"my \'quoted\' string"'); var token = scan('"my \'quoted\' string"');
expect(token.value).to.be('my \'quoted\' string'); expect(token.value).to.be('my \'quoted\' string');
expect(token.type).to.be(ol.expression.TokenType.STRING_LITERAL); expect(token.type).to.be(ol.expr.TokenType.STRING_LITERAL);
}); });
it('parses double quoted string with escaped double quotes', function() { it('parses double quoted string with escaped double quotes', function() {
var token = scan('"my \\"quoted\\" string"'); var token = scan('"my \\"quoted\\" string"');
expect(token.value).to.be('my "quoted" string'); expect(token.value).to.be('my "quoted" string');
expect(token.type).to.be(ol.expression.TokenType.STRING_LITERAL); expect(token.type).to.be(ol.expr.TokenType.STRING_LITERAL);
}); });
it('parses double quoted string with escaped backslash', function() { it('parses double quoted string with escaped backslash', function() {
var token = scan('"my \\\ string"'); var token = scan('"my \\\ string"');
expect(token.value).to.be('my \ string'); expect(token.value).to.be('my \ string');
expect(token.type).to.be(ol.expression.TokenType.STRING_LITERAL); expect(token.type).to.be(ol.expr.TokenType.STRING_LITERAL);
}); });
it('parses double quoted string with unicode escape sequences', function() { it('parses double quoted string with unicode escape sequences', function() {
var token = scan('"\u006f\u006c\u0033"'); var token = scan('"\u006f\u006c\u0033"');
expect(token.value).to.be('ol3'); expect(token.value).to.be('ol3');
expect(token.type).to.be(ol.expression.TokenType.STRING_LITERAL); expect(token.type).to.be(ol.expr.TokenType.STRING_LITERAL);
}); });
it('parses double quoted string with hex escape sequences', function() { it('parses double quoted string with hex escape sequences', function() {
var token = scan('"\x6f\x6c\x33"'); var token = scan('"\x6f\x6c\x33"');
expect(token.value).to.be('ol3'); expect(token.value).to.be('ol3');
expect(token.type).to.be(ol.expression.TokenType.STRING_LITERAL); expect(token.type).to.be(ol.expr.TokenType.STRING_LITERAL);
}); });
it('parses double quoted string with tab', function() { it('parses double quoted string with tab', function() {
var token = scan('"a\ttab"'); var token = scan('"a\ttab"');
expect(token.value).to.be('a\ttab'); expect(token.value).to.be('a\ttab');
expect(token.type).to.be(ol.expression.TokenType.STRING_LITERAL); expect(token.type).to.be(ol.expr.TokenType.STRING_LITERAL);
}); });
it('throws on unterminated double quote', function() { it('throws on unterminated double quote', function() {
expect(function() { expect(function() {
scan('"never \'ending\' string'); scan('"never \'ending\' string');
}).to.throwException(function(err) { }).to.throwException(function(err) {
expect(err).to.be.an(ol.expression.UnexpectedToken); expect(err).to.be.an(ol.expr.UnexpectedToken);
var token = err.token; var token = err.token;
expect(token.type).to.be(ol.expression.TokenType.EOF); expect(token.type).to.be(ol.expr.TokenType.EOF);
expect(token.index).to.be(22); expect(token.index).to.be(22);
}); });
}); });
@@ -450,52 +450,52 @@ describe('ol.expression.Lexer', function() {
it('parses single quoted string', function() { it('parses single quoted string', function() {
var token = scan('\'my string\''); var token = scan('\'my string\'');
expect(token.value).to.be('my string'); expect(token.value).to.be('my string');
expect(token.type).to.be(ol.expression.TokenType.STRING_LITERAL); expect(token.type).to.be(ol.expr.TokenType.STRING_LITERAL);
}); });
it('parses single quoted string with internal double quotes', function() { it('parses single quoted string with internal double quotes', function() {
var token = scan('\'my "quoted" string\''); var token = scan('\'my "quoted" string\'');
expect(token.value).to.be('my "quoted" string'); expect(token.value).to.be('my "quoted" string');
expect(token.type).to.be(ol.expression.TokenType.STRING_LITERAL); expect(token.type).to.be(ol.expr.TokenType.STRING_LITERAL);
}); });
it('parses single quoted string with escaped single quotes', function() { it('parses single quoted string with escaped single quotes', function() {
var token = scan('\'my \\\'quoted\\\' string\''); var token = scan('\'my \\\'quoted\\\' string\'');
expect(token.value).to.be('my \'quoted\' string'); expect(token.value).to.be('my \'quoted\' string');
expect(token.type).to.be(ol.expression.TokenType.STRING_LITERAL); expect(token.type).to.be(ol.expr.TokenType.STRING_LITERAL);
}); });
it('parses single quoted string with escaped backslash', function() { it('parses single quoted string with escaped backslash', function() {
var token = scan('\'my \\\ string\''); var token = scan('\'my \\\ string\'');
expect(token.value).to.be('my \ string'); expect(token.value).to.be('my \ string');
expect(token.type).to.be(ol.expression.TokenType.STRING_LITERAL); expect(token.type).to.be(ol.expr.TokenType.STRING_LITERAL);
}); });
it('parses single quoted string with unicode escape sequences', function() { it('parses single quoted string with unicode escape sequences', function() {
var token = scan('\'\u006f\u006c\u0033\''); var token = scan('\'\u006f\u006c\u0033\'');
expect(token.value).to.be('ol3'); expect(token.value).to.be('ol3');
expect(token.type).to.be(ol.expression.TokenType.STRING_LITERAL); expect(token.type).to.be(ol.expr.TokenType.STRING_LITERAL);
}); });
it('parses single quoted string with hex escape sequences', function() { it('parses single quoted string with hex escape sequences', function() {
var token = scan('\'\x6f\x6c\x33\''); var token = scan('\'\x6f\x6c\x33\'');
expect(token.value).to.be('ol3'); expect(token.value).to.be('ol3');
expect(token.type).to.be(ol.expression.TokenType.STRING_LITERAL); expect(token.type).to.be(ol.expr.TokenType.STRING_LITERAL);
}); });
it('parses single quoted string with tab', function() { it('parses single quoted string with tab', function() {
var token = scan('\'a\ttab\''); var token = scan('\'a\ttab\'');
expect(token.value).to.be('a\ttab'); expect(token.value).to.be('a\ttab');
expect(token.type).to.be(ol.expression.TokenType.STRING_LITERAL); expect(token.type).to.be(ol.expr.TokenType.STRING_LITERAL);
}); });
it('throws on unterminated single quote', function() { it('throws on unterminated single quote', function() {
expect(function() { expect(function() {
scan('\'never "ending" string'); scan('\'never "ending" string');
}).to.throwException(function(err) { }).to.throwException(function(err) {
expect(err).to.be.an(ol.expression.UnexpectedToken); expect(err).to.be.an(ol.expr.UnexpectedToken);
var token = err.token; var token = err.token;
expect(token.type).to.be(ol.expression.TokenType.EOF); expect(token.type).to.be(ol.expr.TokenType.EOF);
expect(token.index).to.be(22); expect(token.index).to.be(22);
}); });
}); });
@@ -504,6 +504,6 @@ describe('ol.expression.Lexer', function() {
}); });
goog.require('ol.expression.Lexer'); goog.require('ol.expr.Lexer');
goog.require('ol.expression.TokenType'); goog.require('ol.expr.TokenType');
goog.require('ol.expression.UnexpectedToken'); goog.require('ol.expr.UnexpectedToken');

102
test/spec/ol/expression/parser.test.js → test/spec/ol/expr/parser.test.js
View File

@@ -1,21 +1,21 @@
goog.provide('ol.test.expression.Parser'); goog.provide('ol.test.expression.Parser');
describe('ol.expression.Parser', function() { describe('ol.expr.Parser', function() {
describe('constructor', function() { describe('constructor', function() {
it('creates a new expression parser', function() { it('creates a new expression parser', function() {
var parser = new ol.expression.Parser(); var parser = new ol.expr.Parser();
expect(parser).to.be.a(ol.expression.Parser); expect(parser).to.be.a(ol.expr.Parser);
}); });
}); });
describe('#parseArguments_()', function() { describe('#parseArguments_()', function() {
function parse(source) { function parse(source) {
var lexer = new ol.expression.Lexer(source); var lexer = new ol.expr.Lexer(source);
var parser = new ol.expression.Parser(); var parser = new ol.expr.Parser();
var expr = parser.parseArguments_(lexer); var expr = parser.parseArguments_(lexer);
expect(lexer.peek().type).to.be(ol.expression.TokenType.EOF); expect(lexer.peek().type).to.be(ol.expr.TokenType.EOF);
return expr; return expr;
} }
@@ -23,13 +23,13 @@ describe('ol.expression.Parser', function() {
var args = parse('(1/3, "foo", true)'); var args = parse('(1/3, "foo", true)');
expect(args).length(3); expect(args).length(3);
expect(args[0]).to.be.a(ol.expression.Math); expect(args[0]).to.be.a(ol.expr.Math);
expect(args[0].evaluate()).to.be(1 / 3); expect(args[0].evaluate()).to.be(1 / 3);
expect(args[1]).to.be.a(ol.expression.Literal); expect(args[1]).to.be.a(ol.expr.Literal);
expect(args[1].evaluate()).to.be('foo'); expect(args[1].evaluate()).to.be('foo');
expect(args[2]).to.be.a(ol.expression.Literal); expect(args[2]).to.be.a(ol.expr.Literal);
expect(args[2].evaluate()).to.be(true); expect(args[2].evaluate()).to.be(true);
}); });
@@ -50,16 +50,16 @@ describe('ol.expression.Parser', function() {
describe('#parseBinaryExpression_()', function() { describe('#parseBinaryExpression_()', function() {
function parse(source) { function parse(source) {
var lexer = new ol.expression.Lexer(source); var lexer = new ol.expr.Lexer(source);
var parser = new ol.expression.Parser(); var parser = new ol.expr.Parser();
var expr = parser.parseBinaryExpression_(lexer); var expr = parser.parseBinaryExpression_(lexer);
expect(lexer.peek().type).to.be(ol.expression.TokenType.EOF); expect(lexer.peek().type).to.be(ol.expr.TokenType.EOF);
return expr; return expr;
} }
it('works with multiplicitave operators', function() { it('works with multiplicitave operators', function() {
var expr = parse('4 * 1e4'); var expr = parse('4 * 1e4');
expect(expr).to.be.a(ol.expression.Math); expect(expr).to.be.a(ol.expr.Math);
expect(expr.evaluate()).to.be(40000); expect(expr.evaluate()).to.be(40000);
expect(parse('10/3').evaluate()).to.be(10 / 3); expect(parse('10/3').evaluate()).to.be(10 / 3);
@@ -67,7 +67,7 @@ describe('ol.expression.Parser', function() {
it('works with additive operators', function() { it('works with additive operators', function() {
var expr = parse('4 +1e4'); var expr = parse('4 +1e4');
expect(expr).to.be.a(ol.expression.Math); expect(expr).to.be.a(ol.expr.Math);
expect(expr.evaluate()).to.be(10004); expect(expr.evaluate()).to.be(10004);
expect(parse('10-3').evaluate()).to.be(7); expect(parse('10-3').evaluate()).to.be(7);
@@ -75,7 +75,7 @@ describe('ol.expression.Parser', function() {
it('works with relational operators', function() { it('works with relational operators', function() {
var expr = parse('4 < 1e4'); var expr = parse('4 < 1e4');
expect(expr).to.be.a(ol.expression.Comparison); expect(expr).to.be.a(ol.expr.Comparison);
expect(expr.evaluate()).to.be(true); expect(expr.evaluate()).to.be(true);
expect(parse('10<3').evaluate()).to.be(false); expect(parse('10<3').evaluate()).to.be(false);
@@ -86,7 +86,7 @@ describe('ol.expression.Parser', function() {
it('works with equality operators', function() { it('works with equality operators', function() {
var expr = parse('4 == 1e4'); var expr = parse('4 == 1e4');
expect(expr).to.be.a(ol.expression.Comparison); expect(expr).to.be.a(ol.expr.Comparison);
expect(expr.evaluate()).to.be(false); expect(expr.evaluate()).to.be(false);
expect(parse('10!=3').evaluate()).to.be(true); expect(parse('10!=3').evaluate()).to.be(true);
@@ -97,7 +97,7 @@ describe('ol.expression.Parser', function() {
it('works with binary logical operators', function() { it('works with binary logical operators', function() {
var expr = parse('true && false'); var expr = parse('true && false');
expect(expr).to.be.a(ol.expression.Logical); expect(expr).to.be.a(ol.expr.Logical);
expect(expr.evaluate()).to.be(false); expect(expr.evaluate()).to.be(false);
expect(parse('false||true').evaluate()).to.be(true); expect(parse('false||true').evaluate()).to.be(true);
@@ -125,16 +125,16 @@ describe('ol.expression.Parser', function() {
describe('#parseGroupExpression_()', function() { describe('#parseGroupExpression_()', function() {
function parse(source) { function parse(source) {
var lexer = new ol.expression.Lexer(source); var lexer = new ol.expr.Lexer(source);
var parser = new ol.expression.Parser(); var parser = new ol.expr.Parser();
var expr = parser.parseGroupExpression_(lexer); var expr = parser.parseGroupExpression_(lexer);
expect(lexer.peek().type).to.be(ol.expression.TokenType.EOF); expect(lexer.peek().type).to.be(ol.expr.TokenType.EOF);
return expr; return expr;
} }
it('parses grouped expressions', function() { it('parses grouped expressions', function() {
var expr = parse('(3 * (foo + 2))'); var expr = parse('(3 * (foo + 2))');
expect(expr).to.be.a(ol.expression.Math); expect(expr).to.be.a(ol.expr.Math);
expect(expr.evaluate({foo: 3})).to.be(15); expect(expr.evaluate({foo: 3})).to.be(15);
}); });
@@ -143,16 +143,16 @@ describe('ol.expression.Parser', function() {
describe('#parseLeftHandSideExpression_()', function() { describe('#parseLeftHandSideExpression_()', function() {
function parse(source) { function parse(source) {
var lexer = new ol.expression.Lexer(source); var lexer = new ol.expr.Lexer(source);
var parser = new ol.expression.Parser(); var parser = new ol.expr.Parser();
var expr = parser.parseLeftHandSideExpression_(lexer); var expr = parser.parseLeftHandSideExpression_(lexer);
expect(lexer.peek().type).to.be(ol.expression.TokenType.EOF); expect(lexer.peek().type).to.be(ol.expr.TokenType.EOF);
return expr; return expr;
} }
it('parses member expressions', function() { it('parses member expressions', function() {
var expr = parse('foo.bar.bam'); var expr = parse('foo.bar.bam');
expect(expr).to.be.a(ol.expression.Member); expect(expr).to.be.a(ol.expr.Member);
}); });
it('throws on invalid member expression', function() { it('throws on invalid member expression', function() {
@@ -163,7 +163,7 @@ describe('ol.expression.Parser', function() {
it('parses call expressions', function() { it('parses call expressions', function() {
var expr = parse('foo(bar)'); var expr = parse('foo(bar)');
expect(expr).to.be.a(ol.expression.Call); expect(expr).to.be.a(ol.expr.Call);
var fns = { var fns = {
foo: function(arg) { foo: function(arg) {
expect(arguments).length(1); expect(arguments).length(1);
@@ -189,34 +189,34 @@ describe('ol.expression.Parser', function() {
describe('#parsePrimaryExpression_()', function() { describe('#parsePrimaryExpression_()', function() {
function parse(source) { function parse(source) {
var lexer = new ol.expression.Lexer(source); var lexer = new ol.expr.Lexer(source);
var parser = new ol.expression.Parser(); var parser = new ol.expr.Parser();
var expr = parser.parsePrimaryExpression_(lexer); var expr = parser.parsePrimaryExpression_(lexer);
expect(lexer.peek().type).to.be(ol.expression.TokenType.EOF); expect(lexer.peek().type).to.be(ol.expr.TokenType.EOF);
return expr; return expr;
} }
it('parses string literal', function() { it('parses string literal', function() {
var expr = parse('"foo"'); var expr = parse('"foo"');
expect(expr).to.be.a(ol.expression.Literal); expect(expr).to.be.a(ol.expr.Literal);
expect(expr.evaluate()).to.be('foo'); expect(expr.evaluate()).to.be('foo');
}); });
it('parses numeric literal', function() { it('parses numeric literal', function() {
var expr = parse('.42e2'); var expr = parse('.42e2');
expect(expr).to.be.a(ol.expression.Literal); expect(expr).to.be.a(ol.expr.Literal);
expect(expr.evaluate()).to.be(42); expect(expr.evaluate()).to.be(42);
}); });
it('parses boolean literal', function() { it('parses boolean literal', function() {
var expr = parse('.42e2'); var expr = parse('.42e2');
expect(expr).to.be.a(ol.expression.Literal); expect(expr).to.be.a(ol.expr.Literal);
expect(expr.evaluate()).to.be(42); expect(expr.evaluate()).to.be(42);
}); });
it('parses null literal', function() { it('parses null literal', function() {
var expr = parse('null'); var expr = parse('null');
expect(expr).to.be.a(ol.expression.Literal); expect(expr).to.be.a(ol.expr.Literal);
expect(expr.evaluate()).to.be(null); expect(expr.evaluate()).to.be(null);
}); });
@@ -225,34 +225,34 @@ describe('ol.expression.Parser', function() {
describe('#parseUnaryExpression_()', function() { describe('#parseUnaryExpression_()', function() {
function parse(source) { function parse(source) {
var lexer = new ol.expression.Lexer(source); var lexer = new ol.expr.Lexer(source);
var parser = new ol.expression.Parser(); var parser = new ol.expr.Parser();
var expr = parser.parseUnaryExpression_(lexer); var expr = parser.parseUnaryExpression_(lexer);
expect(lexer.peek().type).to.be(ol.expression.TokenType.EOF); expect(lexer.peek().type).to.be(ol.expr.TokenType.EOF);
return expr; return expr;
} }
it('parses logical not', function() { it('parses logical not', function() {
var expr = parse('!foo'); var expr = parse('!foo');
expect(expr).to.be.a(ol.expression.Not); expect(expr).to.be.a(ol.expr.Not);
expect(expr.evaluate({foo: true})).to.be(false); expect(expr.evaluate({foo: true})).to.be(false);
}); });
it('works with string literal', function() { it('works with string literal', function() {
var expr = parse('!"foo"'); var expr = parse('!"foo"');
expect(expr).to.be.a(ol.expression.Not); expect(expr).to.be.a(ol.expr.Not);
expect(expr.evaluate()).to.be(false); expect(expr.evaluate()).to.be(false);
}); });
it('works with empty string', function() { it('works with empty string', function() {
var expr = parse('!""'); var expr = parse('!""');
expect(expr).to.be.a(ol.expression.Not); expect(expr).to.be.a(ol.expr.Not);
expect(expr.evaluate()).to.be(true); expect(expr.evaluate()).to.be(true);
}); });
it('works with null', function() { it('works with null', function() {
var expr = parse('!null'); var expr = parse('!null');
expect(expr).to.be.a(ol.expression.Not); expect(expr).to.be.a(ol.expr.Not);
expect(expr.evaluate()).to.be(true); expect(expr.evaluate()).to.be(true);
}); });
@@ -262,14 +262,14 @@ describe('ol.expression.Parser', function() {
}); });
goog.require('ol.expression.Expression'); goog.require('ol.expr.Expression');
goog.require('ol.expression.Call'); goog.require('ol.expr.Call');
goog.require('ol.expression.Comparison'); goog.require('ol.expr.Comparison');
goog.require('ol.expression.Lexer'); goog.require('ol.expr.Lexer');
goog.require('ol.expression.Literal'); goog.require('ol.expr.Literal');
goog.require('ol.expression.Logical'); goog.require('ol.expr.Logical');
goog.require('ol.expression.Math'); goog.require('ol.expr.Math');
goog.require('ol.expression.Member'); goog.require('ol.expr.Member');
goog.require('ol.expression.Not'); goog.require('ol.expr.Not');
goog.require('ol.expression.Parser'); goog.require('ol.expr.Parser');
goog.require('ol.expression.TokenType'); goog.require('ol.expr.TokenType');

638
test/spec/ol/expression/expressions.test.js
View File

@@ -1,638 +0,0 @@
goog.provide('ol.test.expression.Expression');
describe('ol.expression.Call', function() {
describe('constructor', function() {
it('creates a new expression', function() {
var expr = new ol.expression.Call(
new ol.expression.Identifier('sqrt'),
[new ol.expression.Literal(42)]);
expect(expr).to.be.a(ol.expression.Expression);
expect(expr).to.be.a(ol.expression.Call);
});
});
describe('#evaluate()', function() {
var fns = {
sqrt: function(value) {
return Math.sqrt(value);
},
strConcat: function() {
return Array.prototype.join.call(arguments, '');
},
discouraged: function() {
return this.message;
}
};
it('calls method on scope with literal args', function() {
var expr = new ol.expression.Call(
new ol.expression.Identifier('sqrt'),
[new ol.expression.Literal(42)]);
expect(expr.evaluate(fns)).to.be(Math.sqrt(42));
});
it('accepts a separate scope for functions', function() {
var expr = new ol.expression.Call(
new ol.expression.Identifier('sqrt'),
[new ol.expression.Identifier('foo')]);
expect(expr.evaluate({foo: 42}, fns)).to.be(Math.sqrt(42));
});
it('accepts multiple expression arguments', function() {
var expr = new ol.expression.Call(
new ol.expression.Identifier('strConcat'),
[
new ol.expression.Identifier('foo'),
new ol.expression.Literal(' comes after '),
new ol.expression.Math(
ol.expression.MathOp.SUBTRACT,
new ol.expression.Identifier('foo'),
new ol.expression.Literal(1))
]);
expect(expr.evaluate({foo: 42}, fns)).to.be('42 comes after 41');
});
it('accepts optional this arg', function() {
var expr = new ol.expression.Call(
new ol.expression.Identifier('discouraged'), []);
var thisArg = {
message: 'avoid this'
};
expect(expr.evaluate(fns, null, thisArg)).to.be('avoid this');
});
});
var callee = new ol.expression.Identifier('sqrt');
var args = [new ol.expression.Literal(42)];
var expr = new ol.expression.Call(callee, args);
describe('#getArgs()', function() {
it('gets the callee expression', function() {
expect(expr.getArgs()).to.be(args);
});
});
describe('#getCallee()', function() {
it('gets the callee expression', function() {
expect(expr.getCallee()).to.be(callee);
});
});
});
describe('ol.expression.Comparison', function() {
describe('constructor', function() {
it('creates a new expression', function() {
var expr = new ol.expression.Comparison(
ol.expression.ComparisonOp.EQ,
new ol.expression.Identifier('foo'),
new ol.expression.Literal(42));
expect(expr).to.be.a(ol.expression.Expression);
expect(expr).to.be.a(ol.expression.Comparison);
});
});
describe('#evaluate()', function() {
it('compares with ==', function() {
var expr = new ol.expression.Comparison(
ol.expression.ComparisonOp.EQ,
new ol.expression.Identifier('foo'),
new ol.expression.Literal(42));
expect(expr.evaluate({foo: 42})).to.be(true);
expect(expr.evaluate({foo: '42'})).to.be(true);
expect(expr.evaluate({foo: true})).to.be(false);
expect(expr.evaluate({bar: true})).to.be(false);
});
it('compares with !=', function() {
var expr = new ol.expression.Comparison(
ol.expression.ComparisonOp.NEQ,
new ol.expression.Identifier('foo'),
new ol.expression.Literal(42));
expect(expr.evaluate({foo: 42})).to.be(false);
expect(expr.evaluate({foo: '42'})).to.be(false);
expect(expr.evaluate({foo: true})).to.be(true);
expect(expr.evaluate({bar: true})).to.be(true);
});
it('compares with ===', function() {
var expr = new ol.expression.Comparison(
ol.expression.ComparisonOp.STRICT_EQ,
new ol.expression.Identifier('foo'),
new ol.expression.Literal(42));
expect(expr.evaluate({foo: 42})).to.be(true);
expect(expr.evaluate({foo: '42'})).to.be(false);
expect(expr.evaluate({foo: true})).to.be(false);
expect(expr.evaluate({bar: true})).to.be(false);
});
it('compares with !==', function() {
var expr = new ol.expression.Comparison(
ol.expression.ComparisonOp.STRICT_NEQ,
new ol.expression.Identifier('foo'),
new ol.expression.Literal(42));
expect(expr.evaluate({foo: 42})).to.be(false);
expect(expr.evaluate({foo: '42'})).to.be(true);
expect(expr.evaluate({foo: true})).to.be(true);
expect(expr.evaluate({bar: true})).to.be(true);
});
it('compares with >', function() {
var expr = new ol.expression.Comparison(
ol.expression.ComparisonOp.GT,
new ol.expression.Identifier('foo'),
new ol.expression.Literal(42));
expect(expr.evaluate({foo: 42})).to.be(false);
expect(expr.evaluate({foo: 41})).to.be(false);
expect(expr.evaluate({foo: 43})).to.be(true);
});
it('compares with <', function() {
var expr = new ol.expression.Comparison(
ol.expression.ComparisonOp.LT,
new ol.expression.Identifier('foo'),
new ol.expression.Literal(42));
expect(expr.evaluate({foo: 42})).to.be(false);
expect(expr.evaluate({foo: 41})).to.be(true);
expect(expr.evaluate({foo: 43})).to.be(false);
});
it('compares with >=', function() {
var expr = new ol.expression.Comparison(
ol.expression.ComparisonOp.GTE,
new ol.expression.Identifier('foo'),
new ol.expression.Literal(42));
expect(expr.evaluate({foo: 42})).to.be(true);
expect(expr.evaluate({foo: 41})).to.be(false);
expect(expr.evaluate({foo: 43})).to.be(true);
});
it('compares with <=', function() {
var expr = new ol.expression.Comparison(
ol.expression.ComparisonOp.LTE,
new ol.expression.Identifier('foo'),
new ol.expression.Literal(42));
expect(expr.evaluate({foo: 42})).to.be(true);
expect(expr.evaluate({foo: 41})).to.be(true);
expect(expr.evaluate({foo: 43})).to.be(false);
});
});
describe('#isValidOp()', function() {
it('determines if a string is a valid operator', function() {
expect(ol.expression.Comparison.isValidOp('<')).to.be(true);
expect(ol.expression.Comparison.isValidOp('<')).to.be(true);
expect(ol.expression.Comparison.isValidOp('<=')).to.be(true);
expect(ol.expression.Comparison.isValidOp('<=')).to.be(true);
expect(ol.expression.Comparison.isValidOp('==')).to.be(true);
expect(ol.expression.Comparison.isValidOp('!=')).to.be(true);
expect(ol.expression.Comparison.isValidOp('===')).to.be(true);
expect(ol.expression.Comparison.isValidOp('!==')).to.be(true);
expect(ol.expression.Comparison.isValidOp('')).to.be(false);
expect(ol.expression.Comparison.isValidOp('+')).to.be(false);
expect(ol.expression.Comparison.isValidOp('-')).to.be(false);
expect(ol.expression.Comparison.isValidOp('&&')).to.be(false);
});
});
var op = ol.expression.ComparisonOp.LTE;
var left = new ol.expression.Identifier('foo');
var right = new ol.expression.Literal(42);
var expr = new ol.expression.Comparison(op, left, right);
describe('#getOperator()', function() {
it('gets the operator', function() {
expect(expr.getOperator()).to.be(op);
});
});
describe('#getLeft()', function() {
it('gets the left expression', function() {
expect(expr.getLeft()).to.be(left);
});
});
describe('#getRight()', function() {
it('gets the right expression', function() {
expect(expr.getRight()).to.be(right);
});
});
});
describe('ol.expression.Identifier', function() {
describe('constructor', function() {
it('creates a new expression', function() {
var expr = new ol.expression.Identifier('foo');
expect(expr).to.be.a(ol.expression.Expression);
expect(expr).to.be.a(ol.expression.Identifier);
});
});
describe('#evaluate()', function() {
it('returns a number from the scope', function() {
var expr = new ol.expression.Identifier('foo');
expect(expr.evaluate({foo: 42})).to.be(42);
});
it('returns a string from the scope', function() {
var expr = new ol.expression.Identifier('foo');
expect(expr.evaluate({foo: 'chicken'})).to.be('chicken');
});
it('returns a boolean from the scope', function() {
var expr = new ol.expression.Identifier('bar');
expect(expr.evaluate({bar: false})).to.be(false);
expect(expr.evaluate({bar: true})).to.be(true);
});
it('returns a null from the scope', function() {
var expr = new ol.expression.Identifier('nada');
expect(expr.evaluate({nada: null})).to.be(null);
});
it('works for unicode identifiers', function() {
var expr = new ol.expression.Identifier('\u03c0');
expect(expr.evaluate({'\u03c0': Math.PI})).to.be(Math.PI);
});
});
describe('#getName()', function() {
var expr = new ol.expression.Identifier('asdf');
expect(expr.getName()).to.be('asdf');
});
});
describe('ol.expression.Literal', function() {
describe('constructor', function() {
it('creates a new expression', function() {
var expr = new ol.expression.Literal(true);
expect(expr).to.be.a(ol.expression.Expression);
expect(expr).to.be.a(ol.expression.Literal);
});
});
describe('#evaluate()', function() {
it('works for numeric literal', function() {
var expr = new ol.expression.Literal(42e-11);
expect(expr.evaluate()).to.be(4.2e-10);
});
it('works for string literal', function() {
var expr = new ol.expression.Literal('asdf');
expect(expr.evaluate()).to.be('asdf');
});
it('works for boolean literal', function() {
var expr = new ol.expression.Literal(true);
expect(expr.evaluate()).to.be(true);
});
it('works for null literal', function() {
var expr = new ol.expression.Literal(null);
expect(expr.evaluate()).to.be(null);
});
});
describe('#getValue()', function() {
var expr = new ol.expression.Literal('asdf');
expect(expr.getValue()).to.be('asdf');
});
});
describe('ol.expression.Logical', function() {
describe('constructor', function() {
it('creates a new expression', function() {
var expr = new ol.expression.Logical(
ol.expression.LogicalOp.OR,
new ol.expression.Identifier('foo'),
new ol.expression.Identifier('bar'));
expect(expr).to.be.a(ol.expression.Expression);
expect(expr).to.be.a(ol.expression.Logical);
});
});
describe('#evaluate()', function() {
it('applies || to resolved identifiers', function() {
var expr = new ol.expression.Logical(
ol.expression.LogicalOp.OR,
new ol.expression.Identifier('foo'),
new ol.expression.Identifier('bar'));
expect(expr.evaluate({foo: true, bar: true})).to.be(true);
expect(expr.evaluate({foo: true, bar: false})).to.be(true);
expect(expr.evaluate({foo: false, bar: true})).to.be(true);
expect(expr.evaluate({foo: false, bar: false})).to.be(false);
});
it('applies && to resolved identifiers', function() {
var expr = new ol.expression.Logical(
ol.expression.LogicalOp.AND,
new ol.expression.Identifier('foo'),
new ol.expression.Identifier('bar'));
expect(expr.evaluate({foo: true, bar: true})).to.be(true);
expect(expr.evaluate({foo: true, bar: false})).to.be(false);
expect(expr.evaluate({foo: false, bar: true})).to.be(false);
expect(expr.evaluate({foo: false, bar: false})).to.be(false);
});
});
describe('#isValidOp()', function() {
it('determines if a string is a valid operator', function() {
expect(ol.expression.Logical.isValidOp('||')).to.be(true);
expect(ol.expression.Logical.isValidOp('&&')).to.be(true);
expect(ol.expression.Logical.isValidOp('')).to.be(false);
expect(ol.expression.Logical.isValidOp('+')).to.be(false);
expect(ol.expression.Logical.isValidOp('<')).to.be(false);
expect(ol.expression.Logical.isValidOp('|')).to.be(false);
});
});
var op = ol.expression.LogicalOp.AND;
var left = new ol.expression.Identifier('foo');
var right = new ol.expression.Literal(false);
var expr = new ol.expression.Logical(op, left, right);
describe('#getOperator()', function() {
it('gets the operator', function() {
expect(expr.getOperator()).to.be(op);
});
});
describe('#getLeft()', function() {
it('gets the left expression', function() {
expect(expr.getLeft()).to.be(left);
});
});
describe('#getRight()', function() {
it('gets the right expression', function() {
expect(expr.getRight()).to.be(right);
});
});
});
describe('ol.expression.Math', function() {
describe('constructor', function() {
it('creates a new expression', function() {
var expr = new ol.expression.Math(
ol.expression.MathOp.ADD,
new ol.expression.Literal(40),
new ol.expression.Literal(2));
expect(expr).to.be.a(ol.expression.Expression);
expect(expr).to.be.a(ol.expression.Math);
});
});
describe('#evaluate()', function() {
it('does + with numeric literal', function() {
var expr = new ol.expression.Math(
ol.expression.MathOp.ADD,
new ol.expression.Literal(40),
new ol.expression.Literal(2));
expect(expr.evaluate()).to.be(42);
});
it('does + with string literal (note: subject to change)', function() {
var expr = new ol.expression.Math(
ol.expression.MathOp.ADD,
new ol.expression.Literal('foo'),
new ol.expression.Literal('bar'));
expect(expr.evaluate()).to.be('foobar');
});
it('does + with identifiers', function() {
var expr = new ol.expression.Math(
ol.expression.MathOp.ADD,
new ol.expression.Identifier('foo'),
new ol.expression.Identifier('bar'));
expect(expr.evaluate({foo: 40, bar: 2})).to.be(42);
});
it('does - with identifiers', function() {
var expr = new ol.expression.Math(
ol.expression.MathOp.SUBTRACT,
new ol.expression.Identifier('foo'),
new ol.expression.Literal(2));
expect(expr.evaluate({foo: 40})).to.be(38);
});
it('casts to number with - (note: this may throw later)', function() {
var expr = new ol.expression.Math(
ol.expression.MathOp.SUBTRACT,
new ol.expression.Identifier('foo'),
new ol.expression.Literal(2));
expect(expr.evaluate({foo: '40'})).to.be(38);
});
it('does * with identifiers', function() {
var expr = new ol.expression.Math(
ol.expression.MathOp.MULTIPLY,
new ol.expression.Literal(2),
new ol.expression.Identifier('foo'));
expect(expr.evaluate({foo: 21})).to.be(42);
});
it('casts to number with * (note: this may throw later)', function() {
var expr = new ol.expression.Math(
ol.expression.MathOp.MULTIPLY,
new ol.expression.Identifier('foo'),
new ol.expression.Literal(2));
expect(expr.evaluate({foo: '21'})).to.be(42);
});
it('does % with identifiers', function() {
var expr = new ol.expression.Math(
ol.expression.MathOp.MOD,
new ol.expression.Literal(97),
new ol.expression.Identifier('foo'));
expect(expr.evaluate({foo: 55})).to.be(42);
});
it('casts to number with % (note: this may throw later)', function() {
var expr = new ol.expression.Math(
ol.expression.MathOp.MOD,
new ol.expression.Identifier('foo'),
new ol.expression.Literal(100));
expect(expr.evaluate({foo: '150'})).to.be(50);
});
});
describe('#isValidOp()', function() {
it('determines if a string is a valid operator', function() {
expect(ol.expression.Math.isValidOp('+')).to.be(true);
expect(ol.expression.Math.isValidOp('-')).to.be(true);
expect(ol.expression.Math.isValidOp('*')).to.be(true);
expect(ol.expression.Math.isValidOp('/')).to.be(true);
expect(ol.expression.Math.isValidOp('%')).to.be(true);
expect(ol.expression.Math.isValidOp('')).to.be(false);
expect(ol.expression.Math.isValidOp('|')).to.be(false);
expect(ol.expression.Math.isValidOp('&')).to.be(false);
expect(ol.expression.Math.isValidOp('<')).to.be(false);
expect(ol.expression.Math.isValidOp('||')).to.be(false);
expect(ol.expression.Math.isValidOp('.')).to.be(false);
});
});
var op = ol.expression.MathOp.MOD;
var left = new ol.expression.Identifier('foo');
var right = new ol.expression.Literal(20);
var expr = new ol.expression.Math(op, left, right);
describe('#getOperator()', function() {
it('gets the operator', function() {
expect(expr.getOperator()).to.be(op);
});
});
describe('#getLeft()', function() {
it('gets the left expression', function() {
expect(expr.getLeft()).to.be(left);
});
});
describe('#getRight()', function() {
it('gets the right expression', function() {
expect(expr.getRight()).to.be(right);
});
});
});
describe('ol.expression.Member', function() {
describe('constructor', function() {
it('creates a new expression', function() {
var expr = new ol.expression.Member(
new ol.expression.Identifier('foo'),
new ol.expression.Identifier('bar'));
expect(expr).to.be.a(ol.expression.Expression);
expect(expr).to.be.a(ol.expression.Member);
});
});
describe('#evaluate()', function() {
it('accesses an object property', function() {
var expr = new ol.expression.Member(
new ol.expression.Identifier('foo'),
new ol.expression.Identifier('bar'));
var scope = {foo: {bar: 42}};
expect(expr.evaluate(scope)).to.be(42);
});
});
var object = new ol.expression.Identifier('foo');
var property = new ol.expression.Identifier('bar');
var expr = new ol.expression.Member(object, property);
describe('#getObject()', function() {
expect(expr.getObject()).to.be(object);
});
describe('#getProperty()', function() {
expect(expr.getProperty()).to.be(property);
});
});
describe('ol.expression.Not', function() {
describe('constructor', function() {
it('creates a new expression', function() {
var expr = new ol.expression.Not(
new ol.expression.Literal(true));
expect(expr).to.be.a(ol.expression.Expression);
expect(expr).to.be.a(ol.expression.Not);
});
});
describe('#evaluate()', function() {
it('returns the logical complement', function() {
var expr = new ol.expression.Not(new ol.expression.Literal(true));
expect(expr.evaluate()).to.be(false);
expr = new ol.expression.Not(new ol.expression.Literal(false));
expect(expr.evaluate()).to.be(true);
});
it('negates a truthy string', function() {
var expr = new ol.expression.Not(new ol.expression.Literal('asdf'));
expect(expr.evaluate()).to.be(false);
});
it('negates a falsy string', function() {
var expr = new ol.expression.Not(new ol.expression.Literal(''));
expect(expr.evaluate()).to.be(true);
});
it('negates a truthy number', function() {
var expr = new ol.expression.Not(new ol.expression.Literal(42));
expect(expr.evaluate()).to.be(false);
});
it('negates a falsy number', function() {
var expr = new ol.expression.Not(new ol.expression.Literal(NaN));
expect(expr.evaluate()).to.be(true);
});
});
describe('#getArgument()', function() {
var argument = new ol.expression.Literal(true);
var expr = new ol.expression.Not(argument);
expect(expr.getArgument()).to.be(argument);
});
});
goog.require('ol.expression.Call');
goog.require('ol.expression.Comparison');
goog.require('ol.expression.ComparisonOp');
goog.require('ol.expression.Expression');
goog.require('ol.expression.Identifier');
goog.require('ol.expression.Literal');
goog.require('ol.expression.Logical');
goog.require('ol.expression.LogicalOp');
goog.require('ol.expression.Math');
goog.require('ol.expression.MathOp');
goog.require('ol.expression.Member');
goog.require('ol.expression.Not');

26
test/spec/ol/layer/vectorlayer.test.js
View File

@@ -50,8 +50,8 @@ describe('ol.layer.Vector', function() {
layer.addFeatures(features); layer.addFeatures(features);
}); });
var geomFilter = ol.expression.parse('geometryType("linestring")'); var geomFilter = ol.expr.parse('geometryType("linestring")');
var extentFilter = ol.expression.parse('extent(16, 16.3, 48, 48.3)'); var extentFilter = ol.expr.parse('extent(16, 16.3, 48, 48.3)');
it('can filter by geometry type using its GeometryType index', function() { it('can filter by geometry type using its GeometryType index', function() {
sinon.spy(geomFilter, 'evaluate'); sinon.spy(geomFilter, 'evaluate');
@@ -70,10 +70,10 @@ describe('ol.layer.Vector', function() {
}); });
it('can filter by extent and geometry type using its index', function() { it('can filter by extent and geometry type using its index', function() {
var filter1 = new ol.expression.Logical( var filter1 = new ol.expr.Logical(
ol.expression.LogicalOp.AND, geomFilter, extentFilter); ol.expr.LogicalOp.AND, geomFilter, extentFilter);
var filter2 = new ol.expression.Logical( var filter2 = new ol.expr.Logical(
ol.expression.LogicalOp.AND, extentFilter, geomFilter); ol.expr.LogicalOp.AND, extentFilter, geomFilter);
sinon.spy(filter1, 'evaluate'); sinon.spy(filter1, 'evaluate');
sinon.spy(filter2, 'evaluate'); sinon.spy(filter2, 'evaluate');
var subset1 = layer.getFeatures(filter1); var subset1 = layer.getFeatures(filter1);
@@ -85,8 +85,8 @@ describe('ol.layer.Vector', function() {
}); });
it('can handle query using the filter\'s evaluate function', function() { it('can handle query using the filter\'s evaluate function', function() {
var filter = new ol.expression.Logical( var filter = new ol.expr.Logical(
ol.expression.LogicalOp.OR, geomFilter, extentFilter); ol.expr.LogicalOp.OR, geomFilter, extentFilter);
sinon.spy(filter, 'evaluate'); sinon.spy(filter, 'evaluate');
var subset = layer.getFeatures(filter); var subset = layer.getFeatures(filter);
expect(filter.evaluate).to.be.called(); expect(filter.evaluate).to.be.called();
@@ -107,7 +107,7 @@ describe('ol.layer.Vector', function() {
symbolizers: [ symbolizers: [
new ol.style.Line({ new ol.style.Line({
strokeWidth: 2, strokeWidth: 2,
strokeColor: ol.expression.parse('colorProperty'), strokeColor: ol.expr.parse('colorProperty'),
opacity: 1 opacity: 1
}) })
] ]
@@ -144,7 +144,7 @@ describe('ol.layer.Vector', function() {
it('groups equal symbolizers also when defined on features', function() { it('groups equal symbolizers also when defined on features', function() {
var symbolizer = new ol.style.Line({ var symbolizer = new ol.style.Line({
strokeWidth: 3, strokeWidth: 3,
strokeColor: ol.expression.parse('colorProperty'), strokeColor: ol.expr.parse('colorProperty'),
opacity: 1 opacity: 1
}); });
var anotherSymbolizer = new ol.style.Line({ var anotherSymbolizer = new ol.style.Line({
@@ -178,9 +178,9 @@ describe('ol.layer.Vector', function() {
goog.require('goog.dispose'); goog.require('goog.dispose');
goog.require('ol.Feature'); goog.require('ol.Feature');
goog.require('ol.expression'); goog.require('ol.expr');
goog.require('ol.expression.Logical'); goog.require('ol.expr.Logical');
goog.require('ol.expression.LogicalOp'); goog.require('ol.expr.LogicalOp');
goog.require('ol.geom.LineString'); goog.require('ol.geom.LineString');
goog.require('ol.geom.Point'); goog.require('ol.geom.Point');
goog.require('ol.proj'); goog.require('ol.proj');

10
test/spec/ol/style/line.test.js
View File

@@ -42,8 +42,8 @@ describe('ol.style.Line', function() {
it('accepts expressions', function() { it('accepts expressions', function() {
var symbolizer = new ol.style.Line({ var symbolizer = new ol.style.Line({
opacity: ol.expression.parse('value / 100'), opacity: ol.expr.parse('value / 100'),
strokeWidth: ol.expression.parse('widthAttr') strokeWidth: ol.expr.parse('widthAttr')
}); });
expect(symbolizer).to.be.a(ol.style.Line); expect(symbolizer).to.be.a(ol.style.Line);
}); });
@@ -54,8 +54,8 @@ describe('ol.style.Line', function() {
it('evaluates expressions with the given feature', function() { it('evaluates expressions with the given feature', function() {
var symbolizer = new ol.style.Line({ var symbolizer = new ol.style.Line({
opacity: ol.expression.parse('value / 100'), opacity: ol.expr.parse('value / 100'),
strokeWidth: ol.expression.parse('widthAttr') strokeWidth: ol.expr.parse('widthAttr')
}); });
var feature = new ol.Feature({ var feature = new ol.Feature({
@@ -74,6 +74,6 @@ describe('ol.style.Line', function() {
}); });
goog.require('ol.Feature'); goog.require('ol.Feature');
goog.require('ol.expression'); goog.require('ol.expr');
goog.require('ol.style.Line'); goog.require('ol.style.Line');
goog.require('ol.style.LineLiteral'); goog.require('ol.style.LineLiteral');

10
test/spec/ol/style/polygon.test.js
View File

@@ -45,8 +45,8 @@ describe('ol.style.Polygon', function() {
it('accepts expressions', function() { it('accepts expressions', function() {
var symbolizer = new ol.style.Polygon({ var symbolizer = new ol.style.Polygon({
opacity: ol.expression.parse('value / 100'), opacity: ol.expr.parse('value / 100'),
fillColor: ol.expression.parse('fillAttr') fillColor: ol.expr.parse('fillAttr')
}); });
expect(symbolizer).to.be.a(ol.style.Polygon); expect(symbolizer).to.be.a(ol.style.Polygon);
}); });
@@ -57,8 +57,8 @@ describe('ol.style.Polygon', function() {
it('evaluates expressions with the given feature', function() { it('evaluates expressions with the given feature', function() {
var symbolizer = new ol.style.Polygon({ var symbolizer = new ol.style.Polygon({
opacity: ol.expression.parse('value / 100'), opacity: ol.expr.parse('value / 100'),
fillColor: ol.expression.parse('fillAttr') fillColor: ol.expr.parse('fillAttr')
}); });
var feature = new ol.Feature({ var feature = new ol.Feature({
@@ -90,6 +90,6 @@ describe('ol.style.Polygon', function() {
}); });
goog.require('ol.Feature'); goog.require('ol.Feature');
goog.require('ol.expression'); goog.require('ol.expr');
goog.require('ol.style.Polygon'); goog.require('ol.style.Polygon');
goog.require('ol.style.PolygonLiteral'); goog.require('ol.style.PolygonLiteral');

6
test/spec/ol/style/rule.test.js
View File

@@ -13,14 +13,14 @@ describe('ol.style.Rule', function() {
it('returns false when the rule does not apply', function() { it('returns false when the rule does not apply', function() {
rule = new ol.style.Rule({ rule = new ol.style.Rule({
filter: new ol.expression.Literal(false) filter: new ol.expr.Literal(false)
}); });
expect(rule.applies(feature)).to.be(false); expect(rule.applies(feature)).to.be(false);
}); });
it('returns true when the rule applies', function() { it('returns true when the rule applies', function() {
rule = new ol.style.Rule({ rule = new ol.style.Rule({
filter: new ol.expression.Literal(true) filter: new ol.expr.Literal(true)
}); });
expect(rule.applies(feature)).to.be(true); expect(rule.applies(feature)).to.be(true);
}); });
@@ -29,5 +29,5 @@ describe('ol.style.Rule', function() {
}); });
goog.require('ol.Feature'); goog.require('ol.Feature');
goog.require('ol.expression.Literal'); goog.require('ol.expr.Literal');
goog.require('ol.style.Rule'); goog.require('ol.style.Rule');

14
test/spec/ol/style/shape.test.js
View File

@@ -51,8 +51,8 @@ describe('ol.style.Shape', function() {
it('accepts expressions', function() { it('accepts expressions', function() {
var symbolizer = new ol.style.Shape({ var symbolizer = new ol.style.Shape({
size: ol.expression.parse('sizeAttr'), size: ol.expr.parse('sizeAttr'),
strokeColor: ol.expression.parse('color') strokeColor: ol.expr.parse('color')
}); });
expect(symbolizer).to.be.a(ol.style.Shape); expect(symbolizer).to.be.a(ol.style.Shape);
}); });
@@ -63,8 +63,8 @@ describe('ol.style.Shape', function() {
it('evaluates expressions with the given feature', function() { it('evaluates expressions with the given feature', function() {
var symbolizer = new ol.style.Shape({ var symbolizer = new ol.style.Shape({
size: ol.expression.parse('sizeAttr'), size: ol.expr.parse('sizeAttr'),
opacity: ol.expression.parse('opacityAttr'), opacity: ol.expr.parse('opacityAttr'),
fillColor: '#BADA55' fillColor: '#BADA55'
}); });
@@ -99,8 +99,8 @@ describe('ol.style.Shape', function() {
it('applies default type if none provided', function() { it('applies default type if none provided', function() {
var symbolizer = new ol.style.Shape({ var symbolizer = new ol.style.Shape({
size: ol.expression.parse('sizeAttr'), size: ol.expr.parse('sizeAttr'),
opacity: ol.expression.parse('opacityAttr'), opacity: ol.expr.parse('opacityAttr'),
fillColor: '#BADA55' fillColor: '#BADA55'
}); });
@@ -120,7 +120,7 @@ describe('ol.style.Shape', function() {
}); });
goog.require('ol.Feature'); goog.require('ol.Feature');
goog.require('ol.expression'); goog.require('ol.expr');
goog.require('ol.style.Shape'); goog.require('ol.style.Shape');
goog.require('ol.style.ShapeLiteral'); goog.require('ol.style.ShapeLiteral');
goog.require('ol.style.ShapeType'); goog.require('ol.style.ShapeType');