refactor: comparisons tests

src/operators.ts

@@ -28,9 +28,11 @@ function containsStrict(val1, val2): string {
 
 function contains(val1, val2): string {
   const code: string[] = [];
-  code.push(`(typeof ${val1} === 'string' && `);
-  code.push(`typeof ${val2} === 'string' && `);
-  code.push(`${val1}.toLowerCase().includes(${val2}.toLowerCase()))`);
+  code.push(`(typeof ${val1} === 'string' && typeof ${val2} === 'string') ?`);
+  code.push(`(${val1}.toLowerCase().includes(${val2}.toLowerCase()))`);
+  code.push(':');
+  code.push(`(Array.isArray(${val1}) && (${val1}.includes(${val2})`);
+  code.push(`|| (typeof ${val2} === 'string' && ${val1}.includes(${val2}.toLowerCase()))))`);
   return code.join('');
 }
 
@@ -56,7 +58,14 @@ export const binaryOperators = {
 
   '!==': (val1, val2): string => `${val1}!==${val2}`,
 
-  '!=': (val1, val2): string => `${val1}!=${val2}`,
+  '!=': (val1, val2): string => {
+    const code: string[] = [];
+    code.push(`(typeof ${val1} == 'string' && typeof ${val2} == 'string') ?`);
+    code.push(`(${val1}.toLowerCase() != ${val2}.toLowerCase())`);
+    code.push(':');
+    code.push(`(${val1} != ${val2})`);
+    return code.join('');
+  },
 
   '^==': startsWithStrict,
 
@@ -77,11 +86,11 @@ export const binaryOperators = {
   '=~': (val1, val2): string =>
     `(${val2} instanceof RegExp) ? (${val2}.test(${val1})) : (${val1}==${val2})`,
 
-  contains: containsStrict,
+  contains,
 
-  '==*': (val1, val2): string => containsStrict(val2, val1),
+  '==*': (val1, val2): string => containsStrict(val1, val2),
 
-  '=*': (val1, val2): string => contains(val2, val1),
+  '=*': (val1, val2): string => contains(val1, val2),
 
   size: (val1, val2): string => `${val1}.length === ${val2}`,
 

src/parser.ts

@@ -1059,9 +1059,9 @@ export class JsonTemplateParser {
       this.lexer.ignoreTokens(1);
       key = this.parseBaseExpr();
       this.lexer.expect(']');
-    } else if (this.lexer.matchID()) {
+    } else if (this.lexer.matchID() || this.lexer.matchKeyword()) {
       key = this.lexer.value();
-    } else if (this.lexer.matchTokenType(TokenType.STR)) {
+    } else if (this.lexer.matchLiteral() && !this.lexer.matchTokenType(TokenType.REGEXP)) {
       key = this.parseLiteralExpr();
     } else {
       this.lexer.throwUnexpectedToken();
@@ -1070,7 +1070,10 @@ export class JsonTemplateParser {
   }
 
   private parseShortKeyValueObjectPropExpr(): ObjectPropExpression | undefined {
-    if (this.lexer.matchID() && (this.lexer.match(',', 1) || this.lexer.match('}', 1))) {
+    if (
+      (this.lexer.matchID() || this.lexer.matchKeyword()) &&
+      (this.lexer.match(',', 1) || this.lexer.match('}', 1))
+    ) {
       const key = this.lexer.lookahead().value;
       const value = this.parseBaseExpr();
       return {

test/scenarios/bad_templates/object_with_invalid_key.jt

@@ -1 +1 @@
-{1: 2}
+{/1/: 2}

test/scenarios/comparisons/anyof.jt

@@ -0,0 +1,4 @@
+{
+    true: [1, 2] anyof [2, 3],
+    false: [1, 2] anyof [3, 4]
+}

test/scenarios/comparisons/contains.jt

@@ -0,0 +1,4 @@
+{
+    true: ["aBc" ==* "aB", "abc" contains "c", ["a", "b", "c"] contains "c"],
+    false: ["aBc" ==* "ab", "abc" contains "d", ["a", "b", "c"] contains "d"]
+}

test/scenarios/comparisons/data.ts

@@ -2,43 +2,178 @@ import { Scenario } from '../../types';
 
 export const data: Scenario[] = [
   {
-    output: [
-      true,
-      true,
-      true,
-      true,
-      true,
-      true,
-      true,
-      true,
-      true,
-      true,
-      true,
-      true,
-      true,
-      true,
-      true,
-      true,
-      true,
-      true,
-      true,
-      true,
-      true,
-      true,
-      true,
-      true,
-      true,
-      true,
-      true,
-      true,
-      true,
-      true,
-      true,
-      true,
-      true,
-      true,
-      true,
-      true,
-    ],
+    templatePath: 'anyof.jt',
+    output: {
+      true: true,
+      false: false,
+    },
+  },
+  {
+    templatePath: 'contains.jt',
+    output: {
+      true: [true, true, true],
+      false: [false, false, false],
+    },
+  },
+  {
+    templatePath: 'empty.jt',
+    output: {
+      true: [true, true],
+      false: [false, false],
+    },
+  },
+  {
+    templatePath: 'string_contains_ignore_case.jt',
+    output: {
+      true: true,
+      false: false,
+    },
+  },
+  {
+    templatePath: 'ends_with.jt',
+    output: {
+      true: [true, true],
+      false: [false, false],
+    },
+  },
+  {
+    templatePath: 'ends_with_ignore_case.jt',
+    output: {
+      true: [true, true],
+      false: [false, false],
+    },
+  },
+  {
+    templatePath: 'eq.jt',
+    output: {
+      true: true,
+      false: false,
+    },
+  },
+  {
+    templatePath: 'ge.jt',
+    output: {
+      true: true,
+      false: false,
+    },
+  },
+  {
+    templatePath: 'gte.jt',
+    output: {
+      true: true,
+      false: false,
+    },
+  },
+  {
+    templatePath: 'in.jt',
+    output: {
+      true: [true, true],
+      false: [false, false],
+    },
+  },
+  {
+    templatePath: 'le.jt',
+    output: {
+      true: true,
+      false: false,
+    },
+  },
+  {
+    templatePath: 'lte.jt',
+    output: {
+      true: true,
+      false: false,
+    },
+  },
+  {
+    templatePath: 'ne.jt',
+    output: {
+      true: true,
+      false: false,
+    },
+  },
+  {
+    templatePath: 'noneof.jt',
+    output: {
+      true: true,
+      false: false,
+    },
+  },
+  {
+    templatePath: 'not_in.jt',
+    output: {
+      true: [true, true],
+      false: [false, false],
+    },
+  },
+  {
+    templatePath: 'regex.jt',
+    output: {
+      true: [true, true],
+      false: [false, false],
+    },
+  },
+  {
+    templatePath: 'size.jt',
+    output: {
+      true: [true, true],
+      false: [false, false],
+    },
+  },
+  {
+    templatePath: 'starts_with.jt',
+    output: {
+      true: [true, true],
+      false: [false, false],
+    },
+  },
+  {
+    templatePath: 'starts_with_ignore_case.jt',
+    output: {
+      true: [true, true],
+      false: [false, false],
+    },
+  },
+  {
+    templatePath: 'string_eq.jt',
+    output: {
+      true: true,
+      false: false,
+    },
+  },
+  {
+    templatePath: 'string_ne.jt',
+    output: {
+      true: true,
+      false: false,
+    },
+  },
+  {
+    templatePath: 'string_eq_ingore_case.jt',
+    output: {
+      true: true,
+      false: false,
+    },
+  },
+  {
+    templatePath: 'string_ne.jt',
+    output: {
+      true: true,
+      false: false,
+    },
+  },
+  {
+    templatePath: 'string_ne_ingore_case.jt',
+    output: {
+      true: true,
+      false: false,
+    },
+  },
+  {
+    templatePath: 'subsetof.jt',
+    output: {
+      true: [true, true],
+      false: [false, false],
+    },
   },
 ];

test/scenarios/comparisons/empty.jt

@@ -0,0 +1,4 @@
+{
+    true: ["" empty true, [] empty true],
+    false: ["a" empty true, ["a"] empty true]
+}

test/scenarios/comparisons/ends_with.jt

@@ -0,0 +1,4 @@
+{
+    true:["EndsWith" $== "With", "With" ==$ "EndsWith"],
+    false: ["EndsWith" $== "NotWith", "NotWith" ==$ "EndsWith"]
+}

test/scenarios/comparisons/ends_with_ignore_case.jt

@@ -0,0 +1,4 @@
+{
+    true:["EndsWith" $= "with", "with" =$ "EndsWith"],
+    false: ["EndsWith" $= "NotWith", "NotWith" =$ "EndsWith"]
+}

test/scenarios/comparisons/eq.jt

@@ -0,0 +1,4 @@
+{
+    true: 10 == 10,
+    false: 10 == 2
+}

test/scenarios/comparisons/ge.jt

@@ -0,0 +1,4 @@
+{
+    true: 10 > 2,
+    false: 2 > 10
+}

test/scenarios/comparisons/gte.jt

@@ -0,0 +1,4 @@
+{
+    true: 10 >= 10,
+    false: 2 >= 10
+}

test/scenarios/comparisons/in.jt

@@ -0,0 +1,4 @@
+{
+    true: ["a" in ["a", "b"], "a" in {"a": 1, "b": 2}],
+    false: ["c" in ["a", "b"], "c" in {"a": 1, "b": 2}]
+}

test/scenarios/comparisons/le.jt

@@ -0,0 +1,4 @@
+{
+    true: 2 < 10,
+    false: 10 < 2
+}

test/scenarios/comparisons/lte.jt

@@ -0,0 +1,4 @@
+{
+    true: 10 <= 10,
+    false: 10 <= 2
+}

test/scenarios/comparisons/ne.jt

@@ -0,0 +1,4 @@
+{
+    true: 10 != 2,
+    false: 10 != 10
+}

test/scenarios/comparisons/noneof.jt

@@ -0,0 +1,4 @@
+{
+    true: [1, 2] noneof [3, 4],
+    false: [1, 2] noneof [2, 3],
+}

test/scenarios/comparisons/not_in.jt

@@ -0,0 +1,4 @@
+{
+    true: ["c" nin ["a", "b"], "c" nin {"a": 1, "b": 2}],
+    false: ["a" nin ["a", "b"], "a" nin {"a": 1, "b": 2}]
+}

test/scenarios/comparisons/regex.jt

@@ -0,0 +1,4 @@
+{
+    true: ['abc' =~ /a.*c/, 'aBC' =~ /a.*c/i],
+    false: ['abC' =~ /a.*c/, 'aBd' =~ /a.*c/i]
+}

test/scenarios/comparisons/size.jt

@@ -0,0 +1,4 @@
+{
+    true: [["a", "b"] size 2, "ab" size 2],
+    false: [[] size 1, "" size 1]
+}

test/scenarios/comparisons/starts_with.jt

@@ -0,0 +1,4 @@
+{
+    true:["StartsWith" ^== "Starts", "Starts" ==^ "StartsWith"],
+    false: ["StartsWith" ^= "NotStarts", "NotStarts" =^ "StartsWith"]
+}

test/scenarios/comparisons/starts_with_ignore_case.jt

@@ -0,0 +1,4 @@
+{
+    true:["StartsWith" ^= "starts", "starts" =^ "StartsWith"],
+    false: ["StartsWith" ^= "NotStarts", "NotStarts" =^ "StartsWith"]
+}