Handle precedence of expression operators depending on operators and not depending on the global kind of the expression

Author: GuillaumeGomez

src/commands/navigation.js

@@ -1,6 +1,5 @@
 // Commands changing the current location or reloading the page.
 
-const { cleanString } = require('../parser.js');
 const { hasError } = require('../utils.js');
 const { validator } = require('../validator.js');
 
@@ -22,7 +21,8 @@ function parseGoTo(parser) {
         return ret;
     }
 
-    const path = ret.value.value.trim();
+    const path = ret.value.getStringValue();
+    const code = ret.value.displayInCode();
 
     let goto_arg;
     const permissions = 'await arg.browser.overridePermissions(page.url(), arg.permissions);';
@@ -32,11 +32,11 @@ function parseGoTo(parser) {
         || path.startsWith('www.') === true
         || path.startsWith('file://') === true
     ) {
-        goto_arg = `"${cleanString(path)}"`;
+        goto_arg = code;
     } else if (path.startsWith('.')) {
-        goto_arg = `page.url().split("/").slice(0, -1).join("/") + "/${cleanString(path)}"`;
+        goto_arg = `page.url().split("/").slice(0, -1).join("/") + "/" + ${code}`;
     } else if (path.startsWith('/')) {
-        goto_arg = `page.url().split("/").slice(0, -1).join("/") + "${cleanString(path)}"`;
+        goto_arg = `page.url().split("/").slice(0, -1).join("/") + ${code}`;
     } else {
         return {'error': `a relative path or a full URL was expected, found \`${path}\``};
     }

src/parser.js

@@ -158,39 +158,6 @@ function isArrayElementCompatible(expected, elem) {
     return expected.kind === elem.kind;
 }
 
-// Used to concatenate all elements into a string, like `1 + "a" + 12` -> "1a12".
-function concatExprAsString(elems) {
-    let out = '';
-    for (const elem of elems) {
-        if (elem.kind === 'operator') {
-            continue;
-        } else if (['number', 'string', 'boolean'].includes(elem.kind)) {
-            out += elem.value;
-        } else {
-            out += concatExprAsString(elem.value);
-        }
-    }
-    return out;
-}
-
-function concatExprAsObjectPath(elems) {
-    let s = '';
-    const parts = [];
-
-    for (const elem of elems) {
-        if (elem.kind === 'operator') {
-            continue;
-        } else if (elem.kind !== 'object-path') {
-            s += concatExprAsString([elem]);
-        } else {
-            elem.value[0].value = s + elem.value[0].value;
-            parts.push(...elem.value);
-            s = '';
-        }
-    }
-    return parts;
-}
-
 // This function is used when generating an expression interpreted as a boolean.
 function concatExprAsExpr(elems) {
     const out = [];
@@ -261,24 +228,19 @@ function canBeCompared(kind1, kind2) {
 }
 
 function convertAsString(elem) {
-    if (elem.value.some(v => v.kind === 'object-path')) {
-        return new ObjectPathElement(
-            concatExprAsObjectPath(elem.value),
-            elem.startPos,
-            elem.endPos,
-            elem.fullText,
-            elem.line,
-            elem.error,
-        );
-    }
-    return new StringElement(
-        concatExprAsString(elem.value),
-        elem.startPos,
-        elem.endPos,
-        elem.fullText,
-        elem.line,
-        elem.error,
-    );
+    const pos = elem.value.findIndex(v => v.kind === 'object-path');
+    elem.kind = 'string';
+    if (pos !== -1) {
+        // We remove the object-path from the expression.
+        const objPath = elem.value.pop();
+        // We remove the first item of the object path and push it at the end of the expression.
+        elem.value.push(...objPath.value.splice(0, 1));
+        // We put the expression as the first element of the object path.
+        objPath.value.splice(0, 0, elem);
+        // All done!
+        return objPath;
+    }
+    return elem;
 }
 
 function convertExprAs(elem, convertAs) {
@@ -363,7 +325,8 @@ class Element {
     }
 
     isRecursive() {
-        // Only Tuple and JSON elements are "recursive" (meaning they can contain sub-levels).
+        // Expression, Array, Tuple and JSON elements are "recursive" (meaning they can contain
+        // sub-levels).
         return false;
     }
 
@@ -433,6 +396,18 @@ class ExpressionElement extends Element {
         super('expression', value, startPos, endPos, fullText, line, error);
     }
 
+    isRecursive() {
+        return true;
+    }
+
+    displayInCode() {
+        return this.value.map(v => v.displayInCode()).join('');
+    }
+
+    getStringValue() {
+        return this.value.map(v => v.getStringValue()).join('');
+    }
+
     clone() {
         const elems = this.value.map(elem => elem.clone());
         return new this.constructor(
@@ -537,8 +512,8 @@ class ObjectPathElement extends Element {
         super('object-path', value, startPos, endPos, fullText, line, error);
     }
 
-    getStringValue(trim, clean = true) {
-        const content = this.value.map(v => `"${v.getStringValue(clean)}"`).join(',');
+    getStringValue() {
+        const content = this.value.map(v => `${v.displayInCode()}`).join(',');
         return `[${content}]`;
     }