feat: make the parenthesis behavior of parse and stringify simpler and more consistent

Author: josdejong

src/parse.ts

@@ -38,6 +38,7 @@ export function parse(query: string, options?: JSONQueryParseOptions): JSONQuery
       return parseParenthesis()
     }
 
+    const leftParenthesis = query[i] === '('
     let left = parseOperator(precedenceLevel - 1)
 
     while (true) {
@@ -52,7 +53,7 @@ export function parse(query: string, options?: JSONQueryParseOptions): JSONQuery
       const right = parseOperator(precedenceLevel - 1)
 
       const childName = left[0]
-      const chained = name === childName
+      const chained = name === childName && !leftParenthesis
       if (chained && !allVarargOperators.includes(allOperatorsMap[name])) {
         i = start
         break

src/stringify.ts

@@ -1,5 +1,5 @@
 import { isArray } from './is'
-import { extendOperators, extendVarargOperators, operators, varargOperators } from './operators'
+import { extendOperators, operators } from './operators'
 import { unquotedPropertyRegex } from './regexps'
 import type {
   JSONPath,
@@ -37,7 +37,6 @@ export const stringify = (query: JSONQuery, options?: JSONQueryStringifyOptions)
   const customOperators = options?.operators ?? []
   const allOperators = extendOperators(operators, customOperators)
   const allOperatorsMap = Object.assign({}, ...allOperators)
-  const allVarargOperators = extendVarargOperators(varargOperators, customOperators)
 
   const _stringify = (query: JSONQuery, indent: string, parenthesis = false) =>
     isArray(query)
@@ -74,16 +73,9 @@ export const stringify = (query: JSONQuery, options?: JSONQueryStringifyOptions)
         const childName = child?.[0]
         const precedence = allOperators.findIndex((group) => name in group)
         const childPrecedence = allOperators.findIndex((group) => childName in group)
+        const parenthesis = precedence <= childPrecedence && (index > 0 || name === childName)
 
-        const higherPrecedence = precedence > childPrecedence
-        const isFirstArgument = index === 0 // we only support left associative operators
-        const selfWithVarargSupport =
-          isFirstArgument && name === childName && allVarargOperators.includes(op)
-        const notSelf = isFirstArgument && name !== childName
-
-        const noParenthesis = higherPrecedence || selfWithVarargSupport || notSelf
-
-        return _stringify(child, indent + space, !noParenthesis)
+        return _stringify(child, indent + space, parenthesis)
       })
 
       return join(argsStr, [start, ` ${op} `, end], [start, `\n${indent + space}${op} `, end])

test-suite/parse.test.json

@@ -230,6 +230,26 @@
         { "input": "2 * (3 + 4)", "output": ["multiply", 2, ["add", 3, 4]] }
       ]
     },
+    {
+      "category": "operator",
+      "description": "should keep the structure based on parenthesis",
+      "tests": [
+        { "input": "(2 * 3) * 4", "output": ["multiply", ["multiply", 2, 3], 4] },
+        {
+          "input": "((2 * 3) * 4) * 5",
+          "output": ["multiply", ["multiply", ["multiply", 2, 3], 4], 5]
+        },
+        {
+          "input": "(2 * 3) * (4 * 5)",
+          "output": ["multiply", ["multiply", 2, 3], ["multiply", 4, 5]]
+        },
+        { "input": "2 * (3 * 4)", "output": ["multiply", 2, ["multiply", 3, 4]] },
+        { "input": "(2 + 3) + 4", "output": ["add", ["add", 2, 3], 4] },
+        { "input": "2 + (3 + 4)", "output": ["add", 2, ["add", 3, 4]] },
+        { "input": "(2 - 3) - 4", "output": ["subtract", ["subtract", 2, 3], 4] },
+        { "input": "2 - (3 - 4)", "output": ["subtract", 2, ["subtract", 3, 4]] }
+      ]
+    },
     {
       "category": "operator",
       "description": "should throw an error in case of an unknown operator",

test-suite/stringify.test.json

@@ -49,10 +49,10 @@
       "description": "should wrap operators with the same precedence in parenthesis when needed",
       "tests": [
         { "input": ["multiply", 2, 3, 4], "output": "2 * 3 * 4" },
-        { "input": ["multiply", ["multiply", 2, 3], 4], "output": "2 * 3 * 4" },
+        { "input": ["multiply", ["multiply", 2, 3], 4], "output": "(2 * 3) * 4" },
         { "input": ["multiply", 2, ["multiply", 3, 4]], "output": "2 * (3 * 4)" },
         { "input": ["divide", 2, 3, 4], "output": "2 / 3 / 4" },
-        { "input": ["divide", ["divide", 2, 3], 4], "output": "2 / 3 / 4" },
+        { "input": ["divide", ["divide", 2, 3], 4], "output": "(2 / 3) / 4" },
         { "input": ["divide", 2, ["divide", 3, 4]], "output": "2 / (3 / 4)" },
         { "input": ["divide", ["multiply", 2, 3], 4], "output": "2 * 3 / 4" },
         { "input": ["divide", 2, ["multiply", 3, 4]], "output": "2 / (3 * 4)" },
@@ -63,15 +63,15 @@
         },
         { "input": ["multiply", ["divide", 2, 3], 4], "output": "2 / 3 * 4" },
         { "input": ["mod", 2, 3, 4], "output": "2 % 3 % 4" },
-        { "input": ["mod", ["mod", 2, 3], 4], "output": "2 % 3 % 4" },
+        { "input": ["mod", ["mod", 2, 3], 4], "output": "(2 % 3) % 4" },
         { "input": ["mod", 2, ["mod", 3, 4]], "output": "2 % (3 % 4)" },
         { "input": ["mod", ["multiply", 2, 3], 4], "output": "2 * 3 % 4" },
         { "input": ["multiply", ["mod", 2, 3], 4], "output": "2 % 3 * 4" },
         { "input": ["add", 2, 3, 4], "output": "2 + 3 + 4" },
-        { "input": ["add", ["add", 2, 3], 4], "output": "2 + 3 + 4" },
+        { "input": ["add", ["add", 2, 3], 4], "output": "(2 + 3) + 4" },
         { "input": ["add", 2, ["add", 3, 4]], "output": "2 + (3 + 4)" },
         { "input": ["subtract", 2, 3, 4], "output": "2 - 3 - 4" },
-        { "input": ["subtract", ["subtract", 2, 3], 4], "output": "2 - 3 - 4" },
+        { "input": ["subtract", ["subtract", 2, 3], 4], "output": "(2 - 3) - 4" },
         { "input": ["subtract", 2, ["subtract", 3, 4]], "output": "2 - (3 - 4)" },
         { "input": ["subtract", ["add", 2, 3], 4], "output": "2 + 3 - 4" },
         { "input": ["subtract", 2, ["add", 3, 4]], "output": "2 - (3 + 4)" },