@graffiticode/parser 0.1.1 → 0.1.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@graffiticode/parser",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "type": "module",
   "publishConfig": {
     "access": "public"
@@ -8,7 +8,7 @@
   "main": "./src/index.js",
   "devDependencies": {
     "eslint": "^8.38.0",
-    "jest": "^29.5.0",
+    "jest": "^29.7.0",
     "supertest": "^6.3.3"
   },
   "scripts": {
@@ -18,8 +18,6 @@
   },
   "keywords": [],
   "author": "",
-  "license": "ISC",
-  "description": "",
-  "dependencies": {
-  }
+  "license": "MIT",
+  "description": ""
 }

package/src/ast.js

@@ -20,23 +20,23 @@ function nodeToJSON(n) {
   let obj;
   if (typeof n === "object") {
     switch (n.tag) {
-    case "num":
-      obj = n.elts[0];
-      break;
-    case "str":
-      obj = n.elts[0];
-      break;
-    default:
-      obj = {};
-      obj.tag = n.tag;
-      obj.elts = [];
-      if (n.coord) {
-        obj.coord = n.coord;
-      }
-      for (let i = 0; i < n.elts.length; i++) {
-        obj.elts[i] = nodeToJSON(n.elts[i]);
-      }
-      break;
+      case "num":
+        obj = n.elts[0];
+        break;
+      case "str":
+        obj = n.elts[0];
+        break;
+      default:
+        obj = {};
+        obj.tag = n.tag;
+        obj.elts = [];
+        if (n.coord) {
+          obj.coord = n.coord;
+        }
+        for (let i = 0; i < n.elts.length; i++) {
+          obj.elts[i] = nodeToJSON(n.elts[i]);
+        }
+        break;
     }
   } else if (typeof n === "string") {
     obj = n;
@@ -667,6 +667,10 @@ export class Ast {
       nids.push(word.nid || 0);
     }
     const pattern = env.pattern;
+    console.log(
+      "lambda()",
+      "pattern=" + JSON.stringify(pattern, null, 2),
+    );
     Ast.push(ctx, {
       tag: "LAMBDA",
       elts: [{
@@ -674,7 +678,9 @@ export class Ast {
         elts: names
       }, nid, {
         tag: "LIST",
-        elts: pattern
+        elts: [
+          // pattern   // FIXME
+        ],
       }, {
         tag: "LIST",
         elts: nids

package/src/env.js

@@ -1,5 +1,9 @@
 // env
 
+function topEnv(ctx) {
+  return ctx.state.env[ctx.state.env.length - 1];
+}
+
 export class Env {
   static findWord(ctx, lexeme) {
     const env = ctx.state.env;
@@ -13,12 +17,12 @@ export class Env {
   }
 
   static addWord(ctx, lexeme, entry) {
-    window.gcexports.topEnv(ctx).lexicon[lexeme] = entry;
+    topEnv(ctx).lexicon[lexeme] = entry;
     return null;
   }
 
   static addPattern(ctx, pattern) {
-    window.gcexports.topEnv(ctx).pattern.push(pattern);
+    topEnv(ctx).pattern.push(pattern);
   }
 
   static enterEnv(ctx, name) {
@@ -31,7 +35,7 @@ export class Env {
       // return;  // just stop recursing
       throw new Error("runaway recursion");
     }
-    window.gcexports.topEnv(ctx).paramc = ctx.state.paramc;
+    topEnv(ctx).paramc = ctx.state.paramc;
     ctx.state.env.push({
       name,
       lexicon: {},
@@ -41,6 +45,6 @@ export class Env {
 
   static exitEnv(ctx) {
     ctx.state.env.pop();
-    ctx.state.paramc = window.gcexports.topEnv(ctx).paramc;
+    ctx.state.paramc = topEnv(ctx).paramc;
   }
 }

package/src/folder.js

@@ -203,11 +203,16 @@ export class Folder {
         const elts = [];
         for (let i = 0; i < word.length; i++) {
           const elt = Ast.pop(ctx);
-          assertErr(ctx, elt, `Too few arguments for ${word.name}. Expected ${word.length}.`, node.coord);
+          assertErr(
+            ctx,
+            elt,
+            `Too few arguments for ${word.name}. Expected ${word.length}.`,
+            node.coord
+          );
           elts.push(elt);
         }
         if (word.nid) {
-          Ast.fold(ctx, word, elts);
+          Ast.foldApply(ctx, word, elts);
         } else {
           Ast.push(ctx, {
             tag: word.name,
@@ -220,7 +225,7 @@ export class Folder {
         assert(false);
       }
     } else {
-      // assert(false, "unresolved ident "+name);
+      // assertErr(ctx, false, "unresolved ident " + name, node.coord);
       Ast.push(ctx, node);
     }
   }

package/src/folder.spec.js

@@ -0,0 +1,42 @@
+import { Folder } from "./folder.js";
+import { Ast } from "./ast.js";
+
+describe("folder", () => {
+  it("should fold 'add 2 3' to 5", () => {
+    // Arrange
+    const ctx = {
+      state: {
+        nodePool: ["unused"],
+        nodeStack: [],
+        nodeStackStack: [],
+        nodeMap: {},
+        env: [{ name: "global", lexicon: {} }]
+      }
+    };
+
+    // Create nodes for "add 2 3"
+    const n1Id = Ast.intern(ctx, {
+      tag: "NUM",
+      elts: ["2"]
+    });
+
+    const n2Id = Ast.intern(ctx, {
+      tag: "NUM",
+      elts: ["3"]
+    });
+
+    const addNodeId = Ast.intern(ctx, {
+      tag: "ADD",
+      elts: [n1Id, n2Id]
+    });
+
+    // Act
+    Folder.fold(ctx, addNodeId);
+    const resultId = ctx.state.nodeStack.pop();
+    const resultNode = ctx.state.nodePool[resultId];
+
+    // Assert
+    expect(resultNode.tag).toBe("NUM");
+    expect(resultNode.elts[0]).toBe("5");
+  });
+});

package/src/parse.js

@@ -239,7 +239,7 @@ export const parse = (function () {
       scanTime += (t1 - t0);
       ctx.state.nextToken = tk;
       const to = getPos(ctx);
-      ctx.state.nextTokenCoord = {from, to};
+      ctx.state.nextTokenCoord = { from, to };
     } else {
       tk = nextToken;
     }
@@ -1166,7 +1166,7 @@ export const parse = (function () {
           c = nextCC();
         }
       }
-      const coord = {from: getPos(ctx) - lexeme.length, to: getPos(ctx)};
+      const coord = { from: getPos(ctx) - lexeme.length, to: getPos(ctx) };
       assertErr(ctx, c !== 0, `Unterminated string: ${lexeme}`, coord);
       if (quoteChar === CC_BACKTICK && c === CC_DOLLAR &&
           peekCC() === CC_LEFTBRACE) {

package/src/parse.spec.js

@@ -0,0 +1,118 @@
+import { buildParser } from "./parser.js";
+import { mockPromiseValue } from "./testing/index.js";
+
+describe("parse operations", () => {
+  const log = jest.fn();
+
+  it("should parse 'apply (<a b: add a b>) [10 20]'", async () => {
+    // Arrange
+    const cache = new Map();
+    const getLangAsset = mockPromiseValue("{}");
+    const main = {
+      parse: mockPromiseValue({
+        1: {
+          elts: ["a"],
+          tag: "IDENT"
+        },
+        2: {
+          elts: ["b"],
+          tag: "IDENT"
+        },
+        3: {
+          elts: [1, 2],
+          tag: "ADD"
+        },
+        4: {
+          elts: [3],
+          tag: "EXPRS"
+        },
+        5: {
+          elts: [1, 2],
+          tag: "LIST"
+        },
+        6: {
+          elts: [5, 4],
+          tag: "LAMBDA"
+        },
+        7: {
+          elts: ["10"],
+          tag: "NUM"
+        },
+        8: {
+          elts: ["20"],
+          tag: "NUM"
+        },
+        9: {
+          elts: [7, 8],
+          tag: "LIST"
+        },
+        10: {
+          elts: [6, 9],
+          tag: "APPLY"
+        },
+        11: {
+          elts: [10],
+          tag: "EXPRS"
+        },
+        12: {
+          elts: [11],
+          tag: "PROG"
+        },
+        root: 12
+      })
+    };
+    const parser = buildParser({ log, cache, getLangAsset, main });
+    const lang = "0002";
+    const src = "apply (<a b: add a b>) [10 20]..";
+
+    // Act
+    const result = await parser.parse(lang, src);
+
+    // Assert
+    expect(result).toHaveProperty("root", 12);
+    expect(result[10].tag).toBe("APPLY");
+    expect(result[10].elts).toEqual([6, 9]);
+    expect(result[6].tag).toBe("LAMBDA");
+    expect(result[9].tag).toBe("LIST");
+  });
+
+  it("should parse 'hello, world!'", async () => {
+    // Arrange
+    const cache = new Map();
+    const getLangAsset = mockPromiseValue("{}");
+    const main = {
+      parse: mockPromiseValue({
+        1: {
+          elts: [
+            "hello, world"
+          ],
+          tag: "STR"
+        },
+        2: {
+          elts: [
+            1
+          ],
+          tag: "EXPRS"
+        },
+        3: {
+          elts: [
+            2
+          ],
+          tag: "PROG"
+        },
+        root: 3
+      })
+    };
+    const parser = buildParser({ log, cache, getLangAsset, main });
+    const lang = "0002";
+    const src = "'hello, world'..";
+
+    // Act
+    const result = await parser.parse(lang, src);
+
+    // Assert
+    expect(result).toHaveProperty("root", 3);
+    expect(result[1].tag).toBe("STR");
+    expect(result[1].elts).toEqual(["hello, world"]);
+  });
+});

package/src/parse.spec.js~

@@ -0,0 +1,119 @@
+import { jest } from "@jest/globals";
+import { parser, buildParser } from "./parser.js";
+import { mockPromiseValue, mockPromiseError } from "./testing/index.js";
+
+describe("parse operations", () => {
+  const log = jest.fn();
+  
+  it("should parse 'apply (<a b: add a b>) [10 20]'", async () => {
+    // Arrange
+    const cache = new Map();
+    const getLangAsset = mockPromiseValue("{}");
+    const main = {
+      parse: mockPromiseValue({
+        1: {
+          elts: ["a"],
+          tag: "IDENT"
+        },
+        2: {
+          elts: ["b"],
+          tag: "IDENT"
+        },
+        3: {
+          elts: [1, 2],
+          tag: "ADD"
+        },
+        4: {
+          elts: [3],
+          tag: "EXPRS"
+        },
+        5: {
+          elts: [1, 2],
+          tag: "LIST"
+        },
+        6: {
+          elts: [5, 4],
+          tag: "LAMBDA"
+        },
+        7: {
+          elts: ["10"],
+          tag: "NUM"
+        },
+        8: {
+          elts: ["20"],
+          tag: "NUM"
+        },
+        9: {
+          elts: [7, 8],
+          tag: "LIST"
+        },
+        10: {
+          elts: [6, 9],
+          tag: "APPLY"
+        },
+        11: {
+          elts: [10],
+          tag: "EXPRS"
+        },
+        12: {
+          elts: [11],
+          tag: "PROG"
+        },
+        root: 12
+      })
+    };
+    const parser = buildParser({ log, cache, getLangAsset, main });
+    const lang = "0";
+    const src = "apply (<a b: add a b>) [10 20]..";
+
+    // Act
+    const result = await parser.parse(lang, src);
+
+    // Assert
+    expect(result).toHaveProperty("root", 12);
+    expect(result[10].tag).toBe("APPLY");
+    expect(result[10].elts).toEqual([6, 9]);
+    expect(result[6].tag).toBe("LAMBDA");
+    expect(result[9].tag).toBe("LIST");
+  });
+
+  it("should parse 'hello, world!'", async () => {
+    // Arrange
+    const cache = new Map();
+    const getLangAsset = mockPromiseValue("{}");
+    const main = {
+      parse: mockPromiseValue({
+        1: {
+          elts: [
+            "hello, world"
+          ],
+          tag: "STR"
+        },
+        2: {
+          elts: [
+            1
+          ],
+          tag: "EXPRS"
+        },
+        3: {
+          elts: [
+            2
+          ],
+          tag: "PROG"
+        },
+        root: 3
+      })
+    };
+    const parser = buildParser({ log, cache, getLangAsset, main });
+    const lang = "0";
+    const src = "'hello, world'..";
+
+    // Act
+    const result = await parser.parse(lang, src);
+
+    // Assert
+    expect(result).toHaveProperty("root", 3);
+    expect(result[1].tag).toBe("STR");
+    expect(result[1].elts).toEqual(["hello, world"]);
+  });
+});

package/src/parser.spec.js

@@ -1,5 +1,5 @@
 import { jest } from "@jest/globals";
-import { parser, buildParser } from "./parser.js";
+import { buildParser } from "./parser.js";
 import { mockPromiseValue, mockPromiseError } from "./testing/index.js";
 
 describe("lang/parser", () => {
@@ -135,41 +135,17 @@ describe("lang/parser", () => {
     expect(vm.createContext).toHaveBeenCalled();
     expect(vm.runInContext).toHaveBeenCalledWith(rawLexicon, expect.anything());
   });
-  it.skip("should parse 'hello, world!'", async () => {
-    const lang = "0";
-    const src = "'hello, world'..";
-    const ast = {
-      1: {
-        elts: [
-          "hello, world"
-        ],
-        tag: "STR"
-      },
-      2: {
-        elts: [
-          1
-        ],
-        tag: "EXPRS"
-      },
-      3: {
-        elts: [
-          2
-        ],
-        tag: "PROG"
-      },
-      root: 3
-    };
-    await expect(parser.parse(lang, src)).resolves.toStrictEqual(ast);
-  });
-  it.skip("should parse error", async () => {
+  it("should parse error", async () => {
+    // Arrange
+    const cache = new Map();
+    const getLangAsset = mockPromiseValue("{}");
+    const err = new Error("End of program reached.");
+    const main = { parse: mockPromiseError(err) };
+    const parser = buildParser({ log, cache, getLangAsset, main });
     const lang = "0";
     const src = "'hello, world'";
-    await expect(parser.parse(lang, src)).rejects.toThrow("End of program reached");
+
+    // Act & Assert
+    await expect(parser.parse(lang, src)).rejects.toBe(err);
   });
-  // it("should parse error", async () => {
-  //   const lang = "0";
-  //   const src = "'hello, world..";
-  //   const ast = {};
-  //   await expect(parser.parse(lang, src)).rejects.toThrow("End of program reached");
-  // });
 });