Support +/- unary operators for literals

src/ol/expression/expression.js

@@ -2,11 +2,27 @@ goog.provide('ol.expression');
 
 goog.require('ol.Extent');
 goog.require('ol.Feature');
+goog.require('ol.expression.Expression');
 goog.require('ol.expression.Parser');
 goog.require('ol.extent');
 goog.require('ol.geom.GeometryType');
 
 
+/**
+ * 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
+ * function scope.  The feature itself will be used as the `this` argument.
+ *
+ * @param {ol.expression.Expression} expr The expression.
+ * @param {ol.Feature} feature The feature.
+ * @return {*} The result of the expression.
+ */
+ol.expression.evaluateFeature = function(expr, feature) {
+  return expr.evaluate(
+      feature.getAttributes(), ol.expression.lib, feature);
+};
+
+
 /**
  * Parse an expression
  * @param {string} source The expression source (e.g. `'foo + 2'`).

src/ol/expression/parser.js

@@ -199,16 +199,33 @@ ol.expression.Parser.prototype.createMemberExpression_ = function(object,
 
 
 /**
- * Create a unary expression.
+ * Create a unary expression.  The only true unary operator supported here is
+ * "!".  For +/-, we apply the operator to literal expressions and return
+ * another literal.
  *
- * @param {string} op Operator.
+ * @param {ol.expression.Token} op Operator.
  * @param {ol.expression.Expression} argument Expression.
- * @return {ol.expression.Not} The logical not of the input expression.
+ * @return {ol.expression.Expression} The unary expression.
  * @private
  */
 ol.expression.Parser.prototype.createUnaryExpression_ = function(op, argument) {
-  goog.asserts.assert(op === '!');
-  return new ol.expression.Not(argument);
+  goog.asserts.assert(op.value === '!' || op.value === '+' || op.value === '-');
+  var expr;
+  if (op.value === '!') {
+    expr = new ol.expression.Not(argument);
+  } else if (!(argument instanceof ol.expression.Literal)) {
+    throw new ol.expression.UnexpectedToken(op);
+  } else {
+    // we've got +/- literal
+    if (op.value === '+') {
+      expr = this.createLiteral_(
+          + /** @type {number|string|boolean|null} */ (argument.evaluate()));
+    } else {
+      expr = this.createLiteral_(
+          - /** @type {number|string|boolean|null} */ (argument.evaluate()));
+    }
+  }
+  return expr;
 };
 
 
@@ -440,10 +457,11 @@ ol.expression.Parser.prototype.parseUnaryExpression_ = function(lexer) {
   var operator = lexer.peek();
   if (operator.type !== ol.expression.TokenType.PUNCTUATOR) {
     expr = this.parseLeftHandSideExpression_(lexer);
-  } else if (operator.value === '!') {
+  } else if (operator.value === '!' || operator.value === '-' ||
+      operator.value === '+') {
     lexer.skip();
     expr = this.parseUnaryExpression_(lexer);
-    expr = this.createUnaryExpression_('!', expr);
+    expr = this.createUnaryExpression_(operator, expr);
   } else {
     expr = this.parseLeftHandSideExpression_(lexer);
   }