Provide static method to check for valid operators

src/ol/expression/expression.js

@@ -136,6 +136,22 @@ ol.expression.Comparison = function(operator, left, right) {
 goog.inherits(ol.expression.Comparison, ol.expression.Expression);
 
 
+/**
+ * Determine if a given string is a valid comparison operator.
+ * @param {string} candidate Operator to test.
+ * @return {boolean} The operator is valid.
+ */
+ol.expression.Comparison.isValidOp = (function() {
+  var valid = {};
+  for (var key in ol.expression.ComparisonOp) {
+    valid[ol.expression.ComparisonOp[key]] = true;
+  }
+  return function isValidOp(candidate) {
+    return !!valid[candidate];
+  };
+}());
+
+
 /**
  * @inheritDoc
  */
@@ -276,6 +292,22 @@ ol.expression.Logical = function(operator, left, right) {
 goog.inherits(ol.expression.Logical, ol.expression.Expression);
 
 
+/**
+ * Determine if a given string is a valid logical operator.
+ * @param {string} candidate Operator to test.
+ * @return {boolean} The operator is valid.
+ */
+ol.expression.Logical.isValidOp = (function() {
+  var valid = {};
+  for (var key in ol.expression.LogicalOp) {
+    valid[ol.expression.LogicalOp[key]] = true;
+  }
+  return function isValidOp(candidate) {
+    return !!valid[candidate];
+  };
+}());
+
+
 /**
  * @inheritDoc
  */
@@ -341,6 +373,22 @@ ol.expression.Math = function(operator, left, right) {
 goog.inherits(ol.expression.Math, ol.expression.Expression);
 
 
+/**
+ * Determine if a given string is a valid math operator.
+ * @param {string} candidate Operator to test.
+ * @return {boolean} The operator is valid.
+ */
+ol.expression.Math.isValidOp = (function() {
+  var valid = {};
+  for (var key in ol.expression.MathOp) {
+    valid[ol.expression.MathOp[key]] = true;
+  }
+  return function isValidOp(candidate) {
+    return !!valid[candidate];
+  };
+}());
+
+
 /**
  * @inheritDoc
  */

src/ol/expression/parser.js

@@ -126,15 +126,15 @@ ol.expression.Parser.prototype.binaryPrecedence_ = function(token) {
 ol.expression.Parser.prototype.createBinaryExpression_ = function(operator,
     left, right) {
   var expr;
-  if (ol.expression.ComparisonOp.hasOwnProperty(operator)) {
+  if (ol.expression.Comparison.isValidOp(operator)) {
     expr = new ol.expression.Comparison(
         /** @type {ol.expression.ComparisonOp.<string>} */ (operator),
         left, right);
-  } else if (ol.expression.LogicalOp.hasOwnProperty(operator)) {
+  } else if (ol.expression.Logical.isValidOp(operator)) {
     expr = new ol.expression.Logical(
         /** @type {ol.expression.LogicalOp.<string>} */ (operator),
         left, right);
-  } else if (ol.expression.MathOp.hasOwnProperty(operator)) {
+  } else if (ol.expression.Math.isValidOp(operator)) {
     expr = new ol.expression.Math(
         /** @type {ol.expression.MathOp.<string>} */ (operator),
         left, right);

test/spec/ol/expression/expression.test.js

@@ -177,6 +177,24 @@ describe('ol.expression.Comparison', function() {
     });
   });
 
+  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);
+    });
+  });
+
 });
 
 describe('ol.expression.Identifier', function() {
@@ -292,6 +310,18 @@ describe('ol.expression.Logical', function() {
     });
   });
 
+  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);
+    });
+  });
+
 });
 
 describe('ol.expression.Math', function() {
@@ -390,6 +420,24 @@ describe('ol.expression.Math', function() {
     });
   });
 
+  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);
+    });
+  });
+
+
 });
 
 describe('ol.expression.Member', function() {