@graffiticode/parser 1.2.0 → 1.2.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@graffiticode/parser",
-  "version": "1.2.0",
+  "version": "1.2.1",
   "type": "module",
   "publishConfig": {
     "access": "public"

package/src/unparse.js

@@ -89,7 +89,6 @@ function unparseNode(node, lexicon, indent = 0, options = {}) {
     return node.elts[0];
 
   case "LIST": {
-    console.log("LIST");
     // Array literal [a, b, c]
     if (!node.elts || node.elts.length === 0) {
       return "[]";
@@ -213,13 +212,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 +229,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 "";
 

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
+    });
   });
 });