support constant [] and {} expression (#1734)

Author: Danieladu

libraries/adaptive-expressions/src/builtInFunction.ts

@@ -1675,6 +1675,46 @@ export class BuiltInFunctions {
         return {value: result, error};
     }
 
+    private static isEqual(args: any []): boolean {
+        if (args.length === 0 ) {
+            return false;
+        }
+
+        if (args[0] === undefined || args[0] === null) {
+            return args[1] === undefined || args[1] === null;
+        }
+
+        if (Array.isArray(args[0]) && args[0].length === 0 && Array.isArray(args[1]) && args[1].length === 0) {
+            return true;
+        }
+
+        if (BuiltInFunctions.getPropertyCount(args[0]) === 0 && BuiltInFunctions.getPropertyCount(args[1]) === 0) {
+            return true;
+        }
+
+        try
+        {
+            return args[0] === args[1];
+        }
+        catch
+        {
+            return false;
+        }
+    }
+
+    private static getPropertyCount(obj: any): number {
+        let count = -1;
+        if (!Array.isArray(obj)) {
+            if (obj instanceof Map) {
+                count = obj.size;
+            } else if (typeof obj === 'object') {
+                count = Object.keys(obj).length;
+            }
+        }
+
+        return count;
+    }
+
     // tslint:disable-next-line: max-func-body-length
     private static buildFunctionLookup(): Map<string, ExpressionEvaluator> {
         // tslint:disable-next-line: no-unnecessary-local-variable
@@ -1883,10 +1923,10 @@ export class BuiltInFunctions {
                 (args: any []): boolean => args[0] <= args[1], BuiltInFunctions.validateBinaryNumberOrString, BuiltInFunctions.verifyNumberOrString),
             BuiltInFunctions.comparison(
                 ExpressionType.Equal,
-                (args: any []): boolean => args[0] === args[1], BuiltInFunctions.validateBinary),
+                this.isEqual, BuiltInFunctions.validateBinary),
             BuiltInFunctions.comparison(
                 ExpressionType.NotEqual,
-                (args: any []): boolean => args[0] !== args[1], BuiltInFunctions.validateBinary),
+                (args: any []): boolean => !this.isEqual(args), BuiltInFunctions.validateBinary),
             BuiltInFunctions.comparison(
                 ExpressionType.GreaterThan,
                 (args: any []): boolean => args[0] > args[1], BuiltInFunctions.validateBinaryNumberOrString, BuiltInFunctions.verifyNumberOrString),

libraries/adaptive-expressions/src/parser/Expression.g4

@@ -17,6 +17,7 @@ expression
 
 primaryExpression 
     : '(' expression ')'                      #parenthesisExp
+    | CONSTANT                                #constantAtom
     | NUMBER                                  #numericAtom
     | STRING                                  #stringAtom
     | IDENTIFIER                              #idAtom
@@ -42,4 +43,6 @@ NEWLINE : '\r'? '\n' -> skip;
 
 STRING : ('\'' (~'\'')* '\'') | ('"' (~'"')* '"');
 
+CONSTANT : ('[' WHITESPACE* ']') | ('{' WHITESPACE* '}');
+
 INVALID_TOKEN_DEFAULT_MODE : . ;

libraries/adaptive-expressions/src/parser/expressionEngine.ts

@@ -117,6 +117,25 @@ export class ExpressionEngine implements ExpressionParserInterface {
             }
         }
 
+        public visitConstantAtom(context: ep.ConstantAtomContext): Expression {
+            let text: string = context.text;
+            if (text.startsWith('[') && text.endsWith(']')) {
+                text = text.substr(1, text.length - 2).trim();
+                if (text === '') {
+                    return new Constant([]);
+                }
+            }
+
+            if (text.startsWith('{') && text.endsWith('}')) {
+                text = text.substr(1, text.length - 2).trim();
+                if (text === '') {
+                    return new Constant({});
+                }
+            }
+
+            throw new Error(`Unrecognized constant: ${ text }`);
+        }
+
         protected defaultResult = (): Expression => new Constant('');
 
         private readonly MakeExpression = (type: string, ...children: Expression[]): Expression =>