Custom model editor: Allow ==/!= true/false for areas

Author: easbar

web-bundle/src/main/js/custom-model-editor/src/complete.js

@@ -29,8 +29,6 @@ function complete(expression, pos, categories, areas) {
         const suggestions = parseResult.completions.filter(c => {
             // we need to remove our dummy character for the filtering
             const partialToken = tokenPos.token.substring(0, tokenPos.token.length - 1);
-            // todo: be careful with boolean encoded values later! c might not be a string here...
-            // todo: not supported in IE11 for example, need to provide alternative!
             return startsWith(c, partialToken);
         });
         return {

web-bundle/src/main/js/custom-model-editor/src/parse.js

@@ -40,7 +40,8 @@ function parse(expression, categories, areas) {
  * Parses a given list of tokens according to the following grammar.
  *
  * expression -> comparison (logicOperator comparison)*
- * comparison -> enumCategory comparator value | numericCategory numericComparator number | boolean | booleanCategory | booleanCategory comparator boolean | 'in_area_' area | value'(' expression ')'
+ * comparison -> enumCategory comparator value | numericCategory numericComparator number | boolean | booleanCategory |
+ *               booleanCategory comparator boolean | 'in_area_' area | 'in_area_' area comparator boolean | value'(' expression ')'
  * logicOperator -> '&&' | '||'
  * comparator -> '==' | '!='
  * numericComparator -> '>' | '<' | '>=' | '<=' | '==' | '!='
@@ -50,7 +51,7 @@ function parse(expression, categories, areas) {
  *
  * Note that we do not care about operator precedence between && and || because our aim is not
  * actually evaluating the expression, but rather checking the validity.
- * 
+ *
  * The categories parameter is an object that maps category names to objects that contain the category type
  * `enum`, `boolean` or `numeric` and a list of possible (string) values (for `enum` only).
  *
@@ -75,8 +76,7 @@ function parseTokens(tokens, categories, areas) {
         if (v.type === 'enum') {
             if (v.values.length < 1)
                 return error(`no values given for enum category ${k}`);
-        }
-        else if (v.type !== 'boolean' && v.type !== 'numeric')
+        } else if (v.type !== 'boolean' && v.type !== 'numeric')
             return error(`unknown category type: ${v.type} for category ${k}`)
     }
 
@@ -156,10 +156,10 @@ function parseBooleanLiteral() {
 
 function parseBooleanComparison() {
     // rule: comparison -> booleanCategory
-    if (_idx+1 === _tokens.length) {
+    if (_idx + 1 === _tokens.length) {
         _idx++;
         return valid();
-    } else if (comparisonOperators.indexOf(_tokens[_idx+1]) < 0) {
+    } else if (comparisonOperators.indexOf(_tokens[_idx + 1]) < 0) {
         _idx++;
         return valid();
     }
@@ -168,7 +168,7 @@ function parseBooleanComparison() {
     return parseTripleComparison(
         comparisonOperators,
         (category, operator, value) => isBoolean(value),
-        (category, operator, value) =>['true', 'false']
+        (category, operator, value) => ['true', 'false']
     );
 }
 
@@ -180,10 +180,23 @@ function parseArea() {
     }
     const area = token.substring(`in_area_`.length)
     if (_areas.indexOf(area) < 0) {
-        return error(`unknown area: '${area}'`, [_idx, _idx+1], _areas.map(a => 'in_area_' + a));
+        return error(`unknown area: '${area}'`, [_idx, _idx + 1], _areas.map(a => 'in_area_' + a));
     }
-    _idx++;
-    return valid();
+
+    // rule: comparison -> 'in_area_' area
+    if (_idx + 1 === _tokens.length) {
+        _idx++;
+        return valid();
+    } else if (comparisonOperators.indexOf(_tokens[_idx + 1]) < 0) {
+        _idx++;
+        return valid();
+    }
+    // rule: comparison -> 'in_area_' area comparator boolean
+    return parseTripleComparison(
+        comparisonOperators,
+        (category, operator, value) => isBoolean(value),
+        (category, operator, value) => ['true', 'false']
+    );
 }
 
 function parseInvalidAreaOperator() {
@@ -192,7 +205,7 @@ function parseInvalidAreaOperator() {
         console.error(`${token} is a valid area operator and should have been detected earlier`);
         return;
     }
-    return error(`area names must be prefixed with 'in_area_'`, [_idx, _idx+1], _areas.map(a => 'in_area_' + a));
+    return error(`area names must be prefixed with 'in_area_'`, [_idx, _idx + 1], _areas.map(a => 'in_area_' + a));
 }
 
 function parseTripleComparison(allowedComparators, isValid, getAllowedValues) {
@@ -265,7 +278,7 @@ function isArea() {
 function isInvalidAreaOperator() {
     const token = _tokens[_idx];
     // typing something like in_area might be a common error so we provide some support for it
-    return typeof  token === 'string' && (token.substr(0, 3) === 'in_' || _areas.indexOf(token) >= 0);
+    return typeof token === 'string' && (token.substr(0, 3) === 'in_' || _areas.indexOf(token) >= 0);
 }
 
 function isCategory() {
@@ -293,11 +306,11 @@ function isBoolean(value) {
 }
 
 function error(error, range, completions) {
-    return { error, range, completions };
+    return {error, range, completions};
 }
 
 function valid() {
-    return { error: null, range: [], completions: [] };
+    return {error: null, range: [], completions: []};
 }
 
-export { parse, parseTokens };
+export {parse, parseTokens};

web-bundle/src/main/js/custom-model-editor/src/parse.test.js

@@ -34,6 +34,8 @@ describe("parse", () => {
         test_parseTokens_valid(['(', '(', 'a', '!=', 'a1', ')', ')']);
         test_parseTokens_valid(['in_area_area1']);
         test_parseTokens_valid(['(', 'in_area_area1', ')']);
+        test_parseTokens_valid(['in_area_area2', '==', 'true']);
+        test_parseTokens_valid(['(', 'in_area_area1', '!=', 'false', ')']);
         test_parseTokens_valid(['true']);
         test_parseTokens_valid(['(', 'false', ')']);
         test_parseTokens_valid(['bool1']);
@@ -71,6 +73,7 @@ describe("parse", () => {
         test_parseTokens(['in_area_area404'], `unknown area: 'area404'`, [0, 1], ['in_area_area1', 'in_area_area2', 'in_area_area3']);
         test_parseTokens(['in_area1'], `area names must be prefixed with 'in_area_'`, [0, 1], ['in_area_area1', 'in_area_area2', 'in_area_area3']);
         test_parseTokens(['area2'], `area names must be prefixed with 'in_area_'`, [0, 1], ['in_area_area1', 'in_area_area2', 'in_area_area3']);
+        test_parseTokens(['in_area_area1', '<=', 'true'], `unexpected token '<='`, [1, 2], ['||', '&&']);
     });
 
     test("parse single comparison, invalid, numeric and boolean", () => {
@@ -87,6 +90,7 @@ describe("parse", () => {
         test_parseTokens_valid(['a', '==', 'a1', '||', '(', 'b', '==', 'b1', ')', '&&', 'a', '!=', 'a2']);
         test_parseTokens_valid(['in_area_area3', '&&', 'a', '==', 'a1']);
         test_parseTokens_valid(['b', '!=', 'b1', '||', 'in_area_area3']);
+        test_parseTokens_valid(['b', '!=', 'b1', '||', 'in_area_area2', '!=', 'true']);
         test_parseTokens_valid(['bool1', '==', 'false', '&&', 'bool2', '||', 'bool1']);
     });
 
@@ -130,6 +134,7 @@ describe("parse", () => {
         test_parse_valid('num1>0.3 && bool1');
         test_parse_valid('a != a1 && (bool1 || (bool2 && in_area_area2))');
         test_parse_valid('a != a1 && (bool1 != false || (in_area_area2 && bool2))');
+        test_parse_valid('a != a1 && (bool1 != false || ((in_area_area1 == false) && bool2))');
     });
 
     test("parse, invalid", () => {
@@ -152,6 +157,7 @@ describe("parse", () => {
         test_parse('a == a1 || area_1', `unexpected token 'area_1'`, [11, 17], allowedLefts);
         test_parse(' == bool1', `unexpected token '=='`, [1, 3], allowedLefts);
         test_parse('bool1 != a2', `invalid bool1: 'a2'`, [9, 11], ['true', 'false']);
+        test_parse('in_area_area1 == tru || a == a1', `invalid in_area_area1: 'tru'`, [17, 20], ['true', 'false']);
     });
 
     function test_parse_valid(expression) {