Refactor parser and link formatting for improved handling of compound values

- Updated the grammar build command in package.json to use ES format.
- Enhanced the Link class to support formatting for compound values, allowing for better representation of nested structures.
- Modified the Parser class to streamline link collection and transformation, ensuring proper handling of single and nested links.
- Adjusted grammar rules to improve indentation checks and link parsing logic.
- Updated tests to reflect changes in expected output for single and nested links, ensuring consistency with the new formatting logic.

(part of #64)

Author: konard

js/dist/index.js

@@ -6,7 +6,7 @@
   "type": "module",
   "scripts": {
     "build": "bun run build:grammar && bun build src/index.js --outdir=dist --target=node",
-    "build:grammar": "peggy -o src/parser-generated.js src/grammar.pegjs",
+    "build:grammar": "peggy --format es -o src/parser-generated.js src/grammar.pegjs",
     "test": "bun test",
     "test:watch": "bun test --watch"
   },

js/package.json

@@ -77,7 +77,7 @@ export class Link {
   }
 
 
-  format(lessParentheses = false) {
+  format(lessParentheses = false, isCompoundValue = false) {
     // Empty link
     if (this.id === null && (!this.values || this.values.length === 0)) {
       return lessParentheses ? '' : '()';
@@ -86,15 +86,33 @@ export class Link {
     // Link with only ID, no values
     if (!this.values || this.values.length === 0) {
       const escapedId = Link.escapeReference(this.id);
+      // When used as a value in a compound link (created from combining links), wrap in parentheses
+      if (isCompoundValue) {
+        return `(${escapedId})`;
+      }
       return lessParentheses && !this.needsParentheses(this.id) ? escapedId : `(${escapedId})`;
     }
 
     // Format values recursively  
     const valuesStr = this.values.map(v => this.formatValue(v)).join(' ');
 
-    // Link with values only
+    // Link with values only (null id)
     if (this.id === null) {
-      return lessParentheses ? valuesStr : `(${valuesStr})`;
+      // For lessParentheses mode with simple values, don't wrap the whole thing
+      if (lessParentheses) {
+        // Check if all values are simple (no nested values)
+        const allSimple = this.values.every(v => !v.values || v.values.length === 0);
+        if (allSimple) {
+          // Format each value without extra wrapping
+          const simpleValuesStr = this.values.map(v => Link.escapeReference(v.id)).join(' ');
+          return simpleValuesStr;
+        }
+        // For mixed or complex values in lessParentheses mode, still avoid outer wrapper
+        // but keep the inner formatting
+        return valuesStr;
+      }
+      // For normal mode, wrap in parentheses
+      return `(${valuesStr})`;
     }
 
     // Link with ID and values
@@ -108,13 +126,22 @@ export class Link {
       return Link.escapeReference(value.id || '');
     }
 
-    // Simple value (just ID)
+    // Check if we're in a compound link that was created from path combinations
+    // This is indicated by having a parent context passed through
+    const isCompoundFromPaths = this._isFromPathCombination === true;
+    
+    // For compound links from paths, format values with parentheses
+    if (isCompoundFromPaths) {
+      return value.format(false, true);
+    }
+    
+    // Simple link with just an ID - don't wrap in parentheses when used as a value
     if (!value.values || value.values.length === 0) {
       return Link.escapeReference(value.id);
     }
 
-    // Nested structure - always use parentheses for nested values to preserve structure
-    return value.format(false);
+    // Complex value with its own structure - format it normally with parentheses
+    return value.format(false, false);
   }
 
   needsParentheses(str) {

js/src/Link.js

@@ -29,26 +29,20 @@ export class Parser {
   collectLinks(item, parentPath, result) {
     if (!item) return;
 
-    // Handle singlet value links by promoting the single value to id
-    if (item.id == null && item.values && item.values.length === 1 && item.values[0].id !== null && (!item.values[0].values || item.values[0].values.length === 0)) {
-      item.id = item.values[0].id;
-      item.values = [];
-    }
-    
     // For items with children (indented structure)
     if (item.children && item.children.length > 0) {
-      // Add the parent item alone first
-      if (item.id !== undefined) {
-        if (parentPath.length === 0) {
-          result.push(new Link(item.id));
-        } else {
-          result.push(this.combinePathElements(parentPath, new Link(item.id)));
-        }
+      // First create the link for the current item
+      const currentLink = this.transformLink(item);
+      
+      // Add the link combined with parent path
+      if (parentPath.length === 0) {
+        result.push(currentLink);
+      } else {
+        result.push(this.combinePathElements(parentPath, currentLink));
       }
 
-      // Process each child with parent in the path
-      const currentElement = item.id !== undefined ? new Link(item.id) : null;
-      const newPath = currentElement ? [...parentPath, currentElement] : parentPath;
+      // Process each child with this item in the path
+      const newPath = [...parentPath, currentLink];
 
       for (const child of item.children) {
         this.collectLinks(child, newPath, result);
@@ -68,7 +62,9 @@ export class Parser {
   combinePathElements(pathElements, current) {
     if (pathElements.length === 0) return current;
     if (pathElements.length === 1) {
-      return new Link(null, [pathElements[0], current]);
+      const combined = new Link(null, [pathElements[0], current]);
+      combined._isFromPathCombination = true;
+      return combined;
     }
 
     // For multiple path elements, we need to build proper nesting
@@ -80,7 +76,9 @@ export class Parser {
     let parent = this.combinePathElements(parentPath, lastElement);
 
     // Add current element to the built structure
-    return new Link(null, [parent, current]);
+    const combined = new Link(null, [parent, current]);
+    combined._isFromPathCombination = true;
+    return combined;
   }
 
 
@@ -91,22 +89,21 @@ export class Parser {
       return item;
     }
 
-    const link = new Link(item.id || null, []);
-    
+    // Handle simple reference objects like {id: 'a'}
+    if (item.id !== undefined && !item.values && !item.children) {
+      return new Link(item.id);
+    }
+
+    // For items with values, create a link with those values
     if (item.values && Array.isArray(item.values)) {
+      // Create a link with id (if present) and transformed values
+      const link = new Link(item.id || null, []);
       link.values = item.values.map(v => this.transformLink(v));
+      return link;
     }
 
-    if (item.children && Array.isArray(item.children)) {
-      for (const child of item.children) {
-        const childLink = this.transformLink(child);
-        if (childLink) {
-          link.values.push(childLink);
-        }
-      }
-    }
-    
-    return link;
+    // Default case
+    return new Link(item.id || null, []);
   }
 
 }

js/src/Parser.js

@@ -11,27 +11,27 @@
     }
   }
 
-function checkIndentation(spaces) {
-  return spaces.length >= indentationStack[indentationStack.length - 1];
-}
+  function checkIndentation(spaces) {
+    return spaces.length >= indentationStack[indentationStack.length - 1];
+  }
 
   function getCurrentIndentation() {
     return indentationStack[indentationStack.length - 1];
   }
 }
 
-document = _ links:links eof { return links.flat(); }
+document = _ links:links eof { return links; }
   / _ eof { return []; }
 
 links = fl:firstLine list:line* { popIndentation(); return [fl].concat(list || []); }
 
 firstLine = l:element { return l; }
 
-line = spaces:" "* &{ return checkIndentation(spaces); } l:element { return l; }
+line = CHECK_INDENTATION l:element { return l; }
 
-element = e:anyLink PUSH_INDENTATION l:links { 
-    return { id: e.id, values: e.values, children: l }; 
-  } 
+element = e:anyLink PUSH_INDENTATION l:links {
+    return { id: e.id, values: e.values, children: l };
+  }
   / e:anyLink { return e; }
 
 referenceOrLink = l:multiLineAnyLink { return l; } / i:reference { return { id: i }; }
@@ -59,8 +59,6 @@ singleLineValueLink = v:singleLineValues { return { values: v }; }
 
 multiLineValueLink = "(" v:multiLineValues _ ")" { return { values: v }; }
 
-
-
 reference = doubleQuotedReference / singleQuotedReference / simpleReference 
 
 simpleReference = chars:referenceSymbol+ { return chars.join(''); }
@@ -71,6 +69,8 @@ singleQuotedReference = "'" r:[^']+ "'" { return r.join(''); }
 
 PUSH_INDENTATION = spaces:" "* &{ return spaces.length > getCurrentIndentation(); } { pushIndentation(spaces); }
 
+CHECK_INDENTATION = spaces:" "* &{ return checkIndentation(spaces); }
+
 eol = __ ([\r\n]+ / eof)
 
 eof = !.