@graffiticode/parser 1.2.0 → 1.2.2

package/.claude/settings.local.json

@@ -0,0 +1,10 @@
+{
+  "permissions": {
+    "allow": [
+      "Bash(NODE_OPTIONS=--experimental-vm-modules npx jest:*)",
+      "Bash(npx eslint:*)",
+      "Bash(npm test:*)",
+      "Bash(npm publish:*)"
+    ]
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@graffiticode/parser",
-  "version": "1.2.0",
+  "version": "1.2.2",
   "type": "module",
   "publishConfig": {
     "access": "public"
@@ -22,6 +22,6 @@
   "license": "MIT",
   "description": "",
   "dependencies": {
-    "@graffiticode/basis": "^1.6.2"
+    "@graffiticode/basis": "^1.6.3"
   }
 }

package/src/ast.js

@@ -120,6 +120,7 @@ export class Ast {
       case "STR":
       case "IDENT":
       case "BOOL":
+      case "TAG":
         elts[0] = n.elts[0];
         break;
       default:

package/src/folder.js

@@ -28,6 +28,7 @@ export class Folder {
       // "MUL": mul,
       // "DIV": div,
       // "SUB": sub,
+      TAG: Folder.tag,
       ADD: Folder.add,
       POW: Folder.pow,
       MOD: Folder.mod,
@@ -227,8 +228,8 @@ export class Folder {
     } else {
       // Tag value.
       Ast.push(ctx, {
-        tag: name,
-        elts: [],
+        tag: "TAG",
+        elts: [name],
         coord: node.coord,
       });
     }
@@ -245,6 +246,10 @@ export class Folder {
   static bool(node) {
     Ast.bool(Folder.#ctx, node.elts[0]);
   }
+
+  static tag(node) {
+    Ast.push(Folder.#ctx, node);
+  }
 }
 
 // Keep backward compatibility export

package/src/unparse.js

@@ -46,9 +46,9 @@ function unparseNode(node, lexicon, indent = 0, options = {}) {
     if (node.elts.length >= 3) {
       const first = node.elts[0];
       // Check if first element is an identifier that could be a function
-      if (first && first.tag && first.elts && first.elts.length === 0) {
+      if (first && first.tag === "TAG") {
         // This might be a function name followed by arguments
-        const funcName = first.tag;
+        const funcName = first.elts[0];
         // Check if this matches a lexicon function
         if (lexicon && lexicon[funcName]) {
           const arity = lexicon[funcName].arity || 0;
@@ -88,8 +88,10 @@ function unparseNode(node, lexicon, indent = 0, options = {}) {
   case "IDENT":
     return node.elts[0];
 
+  case "TAG":
+    return node.elts[0];
+
   case "LIST": {
-    console.log("LIST");
     // Array literal [a, b, c]
     if (!node.elts || node.elts.length === 0) {
       return "[]";
@@ -213,13 +215,15 @@ function unparseNode(node, lexicon, indent = 0, options = {}) {
     // If-then-else
     if (node.elts && node.elts.length >= 2) {
       const cond = unparseNode(node.elts[0], lexicon, indent, opts);
-      const thenExpr = unparseNode(node.elts[1], lexicon, indent, opts);
+      const innerIndent = indent + opts.indentSize;
+      const indentStr = " ".repeat(innerIndent);
+      const thenExpr = unparseNode(node.elts[1], lexicon, innerIndent, opts);
 
       if (node.elts.length >= 3) {
-        const elseExpr = unparseNode(node.elts[2], lexicon, indent, opts);
-        return `if ${cond} then ${thenExpr} else ${elseExpr}`;
+        const elseExpr = unparseNode(node.elts[2], lexicon, innerIndent, opts);
+        return `if ${cond} then\n${indentStr}${thenExpr}\nelse\n${indentStr}${elseExpr}`;
       } else {
-        return `if ${cond} then ${thenExpr}`;
+        return `if ${cond} then\n${indentStr}${thenExpr}`;
       }
     }
     return "";
@@ -228,17 +232,39 @@ function unparseNode(node, lexicon, indent = 0, options = {}) {
     // Case expression
     if (node.elts && node.elts.length > 0) {
       const expr = unparseNode(node.elts[0], lexicon, indent, opts);
-      const cases = node.elts.slice(1).map(c => unparseNode(c, lexicon, indent, opts));
-      return `case ${expr} of ${cases.join(" | ")}`;
+      const innerIndent = indent + opts.indentSize;
+      const indentStr = " ".repeat(innerIndent);
+      const endIndentStr = " ".repeat(indent);
+
+      // Process each case branch with proper indentation
+      const cases = node.elts.slice(1).map(c => {
+        // Pass the inner indent to OF nodes but don't add extra indentation here
+        // The OF node will handle its own formatting
+        const caseStr = unparseNode(c, lexicon, indent, opts);
+        return caseStr;
+      });
+
+      return `case ${expr} of\n${cases.join("\n")}\n${endIndentStr}end`;
     }
     return "";
 
   case "OF":
     // Case branch
     if (node.elts && node.elts.length >= 2) {
+      const indentStr = " ".repeat(indent + opts.indentSize);
       const pattern = unparseNode(node.elts[0], lexicon, indent, opts);
-      const expr = unparseNode(node.elts[1], lexicon, indent, opts);
-      return `${pattern} => ${expr}`;
+
+      // Check if the expression is a CASE node for proper nested formatting
+      const exprNode = node.elts[1];
+      let expr;
+      if (exprNode && exprNode.tag === "CASE") {
+        // For nested case, don't add extra indent to the case keyword itself
+        expr = unparseNode(exprNode, lexicon, indent + opts.indentSize, opts);
+      } else {
+        expr = unparseNode(exprNode, lexicon, indent, opts);
+      }
+
+      return `${indentStr}${pattern}: ${expr}`;
     }
     return "";
 
@@ -348,6 +374,7 @@ function reconstructNode(pool, nodeId) {
   case "STR":
   case "IDENT":
   case "BOOL":
+  case "TAG":
     // These nodes have primitive values in elts[0]
     result.elts = [node.elts[0]];
     break;

package/src/unparse.spec.js

@@ -16,7 +16,7 @@ describe("unparse", () => {
     it("should unparse string literals", async () => {
       const source = "'hello, world'..";
       const unparsed = await testRoundTrip(source);
-      expect(unparsed).toBe("'hello, world'..");
+      expect(unparsed).toBe('"hello, world"..');
     });
 
     it.skip("should unparse string literals with escaped quotes", async () => {
@@ -218,14 +218,14 @@ describe("unparse", () => {
 
     it("should unparse if-then-else expression", async () => {
       const source = "if true then 1 else 2..";
-      const unparsed = await testRoundTrip(source);
-      expect(unparsed).toBe("if true then 1 else 2..");
+      const unparsed = await testRoundTrip(source, {}, { compact: false });
+      expect(unparsed).toBe("if true then\n  1\nelse\n  2..");
     });
 
     it("should unparse nested if expressions", async () => {
       const source = "if true then (if false then 1 else 2) else 3..";
-      const unparsed = await testRoundTrip(source);
-      expect(unparsed).toBe("if true then (if false then 1 else 2) else 3..");
+      const unparsed = await testRoundTrip(source, {}, { compact: false });
+      expect(unparsed).toBe("if true then\n  (if false then\n    1\nelse\n    2)\nelse\n  3..");
     });
   });
 
@@ -328,7 +328,7 @@ describe("unparse", () => {
     it("should reformat multiple expressions", async () => {
       const source = "'hello'.[1, 2].{x: 10}..";
       const reformatted = await parser.reformat(0, source, basisLexicon);
-      expect(reformatted).toContain("'hello'");
+      expect(reformatted).toContain('"hello"');
       expect(reformatted).toContain("[\n  1");
       expect(reformatted).toContain("{\n  x: 10");
       expect(reformatted).toContain("..");
@@ -346,5 +346,11 @@ describe("unparse", () => {
       expect(reformatted).toContain("    1"); // 4 spaces
       expect(reformatted).toContain("    2"); // 4 spaces
     });
+
+    it("should preserve escaped quotes in strings", async () => {
+      const source = '"\\\"hello\\\""..'
+      const reformatted = await parser.reformat(0, source, basisLexicon, { compact: true });
+      expect(reformatted).toBe('"\\\"hello\\\""..'); // Should produce identical program
+    });
   });
 });