Add lexical validation for variable not present

src/syntax.js

@@ -51,6 +51,41 @@ function isFalsy (val) {
   return val === false || undefined === val || val === null
 }
 
+function validateExpression(exp, scope, errors = []) {
+  assert(scope, 'unable to evalExp: scope undefined')
+  var operatorREs = lexical.operators
+  var match;
+  for (var i = 0; i < operatorREs.length; i++) {
+    var operatorRE = operatorREs[i]
+    var expRE = new RegExp(`^(${lexical.quoteBalanced.source})(${operatorRE.source})(${lexical.quoteBalanced.source})$`)
+    if ((match = exp.match(expRE))) {
+      errors.concat(validateExpression(match[1], scope, errors), validateExpression(match[3], scope, errors));
+      return errors;
+    }
+  }
+  if((error = validateValue(exp, scope))) {
+    errors.push(error);
+  }
+  return errors;
+}
+
+function validateValue (str, scope) {
+  str = str && str.trim()
+  if (!str) return `Invalid Operator Usage`;
+
+  if (lexical.isLiteral(str)) {
+    return;
+  }
+  if (lexical.isVariable(str)) {
+    if(scope.get(str) !== undefined && scope.get(str) !== null) {
+      return;
+    } else {
+      return `${str} variable not present`
+    }
+  }
+  return `cannot eval '${str}' as value`
+}
+
 module.exports = {
-  evalExp, evalValue, isTruthy, isFalsy
+  evalExp, evalValue, isTruthy, isFalsy, validateExpression, validateValue
 }

test/syntax.js

@@ -6,6 +6,7 @@ var Scope = require('../src/scope.js')
 var evalExp = syntax.evalExp
 var evalValue = syntax.evalValue
 var isTruthy = syntax.isTruthy
+var validateExp = syntax.validateExpression
 
 describe('expression', function () {
   var scope
@@ -74,6 +75,24 @@ describe('expression', function () {
       expect(evalExp('"<=" == "<="', scope)).to.equal(true)
     })
 
+    it('should validate simple expression', function () {
+      expect(validateExp('1<2', scope)).to.deep.equal([]);
+      expect(validateExp('1<!2', scope)).to.deep.equal(["cannot eval '!2' as value"]);
+      expect(validateExp('y<2', scope)).to.deep.equal(["y variable not present"]);
+      expect(validateExp('y<!2', scope)).to.deep.equal(["y variable not present", "cannot eval '!2' as value"]);
+      expect(validateExp('x<2', scope)).to.deep.equal([]);
+      expect(validateExp('x!=<2', scope)).to.deep.equal(["Invalid Operator Usage"]);
+    })
+
+    it('should validate complex expression', function () {
+      expect(validateExp('1<2 and 2<3', scope)).to.deep.equal([]);
+      expect(validateExp('1<!2 and 2<3', scope)).to.deep.equal(["cannot eval '!2' as value"]);
+      expect(validateExp('y<2 and z<3', scope)).to.deep.equal(["y variable not present", "z variable not present"]);
+      expect(validateExp('y<!2 and z<3', scope)).to.deep.equal(["y variable not present", "cannot eval '!2' as value", "z variable not present"]);
+      expect(validateExp('x<2 and x<3', scope)).to.deep.equal([]);
+      expect(validateExp('x!=<2 and x<===3', scope)).to.deep.equal(["Invalid Operator Usage", "Invalid Operator Usage"]);
+    })
+
     describe('complex expression', function () {
       it('should support value or value', function () {
         expect(evalExp('false or true', scope)).to.equal(true)