@graffiticode/parser 0.3.0 → 1.0.0

package/package.json

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

package/src/index.js

@@ -1,2 +1 @@
 export { parser } from "./parser.js";
-export { unparse } from "./unparse.js";

package/src/parser.js

@@ -1,5 +1,3 @@
-import vm from "vm";
-import { getLangAsset } from "../../api/src/lang/index.js";
 import { parse } from "./parse.js";
 import { unparse } from "./unparse.js";
 
@@ -40,58 +38,30 @@ const main = {
   }
 };
 
-export const buildParser = ({
-  log,
-  cache,
-  getLangAsset,
-  main,
-  vm
-}) => {
+export const buildParser = ({ main }) => {
   return {
-    async parse(lang, src) {
-      if (!cache.has(lang)) {
-        let data = await getLangAsset(lang, "/lexicon.js");
-        // TODO Make lexicon JSON.
-        if (data instanceof Buffer) {
-          data = data.toString();
-        }
-        if (typeof (data) !== "string") {
-          log(`Failed to get usable lexicon for ${lang}`, typeof (data), data);
-          throw new Error("unable to use lexicon");
-        }
-        const lstr = data.substring(data.indexOf("{"));
-        let lexicon;
-        try {
-          lexicon = JSON.parse(lstr);
-        } catch (err) {
-          if (err instanceof SyntaxError) {
-            log(`failed to parse ${lang} lexicon: ${err.message}`);
-            const context = { window: { gcexports: {} } };
-            vm.createContext(context);
-            vm.runInContext(data, context);
-            if (typeof (context.window.gcexports.globalLexicon) === "object") {
-              lexicon = context.window.gcexports.globalLexicon;
-            }
-          }
-          if (!lexicon) {
-            throw new Error("Malformed lexicon");
-          }
-        }
-        cache.set(lang, lexicon);
-      };
-      const lexicon = cache.get(lang);
+    async parse(lang, src, lexicon) {
+      // Lexicon is now required
+      if (!lexicon) {
+        throw new Error("Lexicon is required for parsing");
+      }
       return await main.parse(src, lexicon);
     }
   };
 };
 
 export const parser = buildParser({
-  log: console.log,
-  cache: new Map(),
-  getLangAsset,
-  main,
-  vm
+  main
 });
 
 // Add unparse as a property of parser
 parser.unparse = unparse;
+
+// Add reformat function that parses and unparses code
+parser.reformat = async function(lang, src, lexicon, options = {}) {
+  if (!lexicon) {
+    throw new Error("Lexicon is required for reformatting");
+  }
+  const ast = await this.parse(lang, src, lexicon);
+  return unparse(ast, lexicon, options);
+};

package/src/parser.spec.js

@@ -1,153 +1,96 @@
 import { jest } from "@jest/globals";
 import { buildParser, parser } from "./parser.js";
 import { mockPromiseValue, mockPromiseError } from "./testing/index.js";
-import vm from "vm";
+import { lexicon as basisLexicon } from "@graffiticode/basis";
 
 describe("lang/parser", () => {
   const log = jest.fn();
-  it("should call main parser language lexicon", async () => {
+  it("should use provided lexicon", async () => {
     // Arrange
-    const cache = new Map();
-    const getLangAsset = mockPromiseValue("{}");
     const main = {
       parse: mockPromiseValue({ root: "0" })
     };
-    const parser = buildParser({ log, cache, getLangAsset, main });
+    const parser = buildParser({ main });
     const lang = "0";
     const src = "'foo'..";
+    const providedLexicon = { test: "lexicon" };
 
     // Act
-    await expect(parser.parse(lang, src)).resolves.toStrictEqual({ root: "0" });
+    await expect(parser.parse(lang, src, providedLexicon)).resolves.toStrictEqual({ root: "0" });
 
     // Assert
-    expect(getLangAsset).toHaveBeenCalledWith(lang, "/lexicon.js");
-    expect(main.parse).toHaveBeenCalledWith(src, {});
-    expect(cache.has(lang)).toBe(true);
-    expect(cache.get(lang)).toStrictEqual({});
+    expect(main.parse).toHaveBeenCalledWith(src, providedLexicon);
   });
-  it("should call main parser cached lexicon", async () => {
+
+  it("should throw error when lexicon is missing", async () => {
     // Arrange
-    const cache = new Map();
     const main = {
       parse: mockPromiseValue({ root: "0" })
     };
-    const parser = buildParser({
-      cache,
-      main
-    });
+    const parser = buildParser({ main });
     const lang = "0";
     const src = "'foo'..";
-    cache.set(lang, {});
-
-    // Act
-    await expect(parser.parse(lang, src)).resolves.toStrictEqual({ root: "0" });
-
-    // Assert
-    expect(main.parse).toHaveBeenCalledWith(src, {});
-  });
-  it("should return error if get language asset fails", async () => {
-    // Arrange
-    const cache = new Map();
-    const err = new Error("failed to get lexicon");
-    const getLangAsset = mockPromiseError(err);
-    const parser = buildParser({
-      cache,
-      getLangAsset
-    });
-    const lang = "00";
-    const src = "'foo'..";
 
-    // Act
-    await expect(parser.parse(lang, src)).rejects.toBe(err);
-
-    // Assert
-    expect(getLangAsset).toHaveBeenCalledWith(lang, "/lexicon.js");
+    // Act & Assert
+    await expect(parser.parse(lang, src)).rejects.toThrow("Lexicon is required for parsing");
   });
-  it("should return error if main parser fails", async () => {
+  it("should pass lexicon to main parser", async () => {
     // Arrange
-    const log = jest.fn();
-    const cache = new Map();
-    const getLangAsset = mockPromiseValue("{}");
-    const err = new Error("main parser failed");
-    const main = { parse: mockPromiseError(err) };
-    const parser = buildParser({ log, cache, getLangAsset, main });
+    const main = {
+      parse: mockPromiseValue({ root: "0" })
+    };
+    const parser = buildParser({ main });
     const lang = "0";
     const src = "'foo'..";
+    const lexicon = { someFunc: { name: "SOMEFUNC" } };
 
     // Act
-    await expect(parser.parse(lang, src)).rejects.toBe(err);
+    await expect(parser.parse(lang, src, lexicon)).resolves.toStrictEqual({ root: "0" });
 
     // Assert
-    expect(getLangAsset).toHaveBeenCalledWith(lang, "/lexicon.js");
-    expect(main.parse).toHaveBeenCalledWith(src, {});
-    expect(cache.has(lang)).toBe(true);
-    expect(cache.get(lang)).toStrictEqual({});
+    expect(main.parse).toHaveBeenCalledWith(src, lexicon);
   });
-  it("should return succeed if lexicon is a buffer", async () => {
+  it("should return error if main parser fails with lexicon", async () => {
     // Arrange
-    const log = jest.fn();
-    const cache = new Map();
-    const getLangAsset = mockPromiseValue(Buffer.from("{}"));
-    const ast = { root: "0" };
-    const main = { parse: mockPromiseValue(ast) };
-    const parser = buildParser({ log, cache, getLangAsset, main });
-    const lang = "0";
+    const err = new Error("parser failed");
+    const main = { parse: mockPromiseError(err) };
+    const parser = buildParser({ main });
+    const lang = "00";
     const src = "'foo'..";
+    const lexicon = {};
 
     // Act
-    await expect(parser.parse(lang, src)).resolves.toStrictEqual(ast);
+    await expect(parser.parse(lang, src, lexicon)).rejects.toBe(err);
 
     // Assert
-    expect(getLangAsset).toHaveBeenCalledWith(lang, "/lexicon.js");
-    expect(main.parse).toHaveBeenCalledWith(src, {});
-    expect(cache.has(lang)).toBe(true);
-    expect(cache.get(lang)).toStrictEqual({});
+    expect(main.parse).toHaveBeenCalledWith(src, lexicon);
   });
-  it("should try vm if lexicon cannot parse JSON", async () => {
+  it("should return error if main parser fails", async () => {
     // Arrange
-    const log = jest.fn();
-    const cache = new Map();
-    const rawLexicon = `
-    (() => {
-      window.gcexports.globalLexicon = {};
-    })();
-    `;
-    const getLangAsset = mockPromiseValue(rawLexicon);
-    const ast = { root: "0" };
-    const main = { parse: mockPromiseValue(ast) };
-    const vm = {
-      createContext: jest.fn(),
-      runInContext: jest.fn().mockImplementation((data, context) => {
-        context.window.gcexports.globalLexicon = {};
-      })
-    };
-    const parser = buildParser({ log, cache, getLangAsset, main, vm });
+    const err = new Error("main parser failed");
+    const main = { parse: mockPromiseError(err) };
+    const parser = buildParser({ main });
     const lang = "0";
     const src = "'foo'..";
+    const lexicon = {};
 
     // Act
-    await expect(parser.parse(lang, src)).resolves.toStrictEqual(ast);
+    await expect(parser.parse(lang, src, lexicon)).rejects.toBe(err);
 
     // Assert
-    expect(getLangAsset).toHaveBeenCalledWith(lang, "/lexicon.js");
-    expect(main.parse).toHaveBeenCalledWith(src, {});
-    expect(cache.has(lang)).toBe(true);
-    expect(cache.get(lang)).toStrictEqual({});
-    expect(vm.createContext).toHaveBeenCalled();
-    expect(vm.runInContext).toHaveBeenCalledWith(rawLexicon, expect.anything());
+    expect(main.parse).toHaveBeenCalledWith(src, lexicon);
   });
   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 parser = buildParser({ main });
     const lang = "0";
     const src = "'hello, world'";
+    const lexicon = {};
 
     // Act & Assert
-    await expect(parser.parse(lang, src)).rejects.toBe(err);
+    await expect(parser.parse(lang, src, lexicon)).rejects.toBe(err);
   });
 });
 
@@ -155,7 +98,7 @@ describe("parser integration tests", () => {
   // Tests using the actual parser
   it("should parse string literals", async () => {
     // Arrange & Act
-    const result = await parser.parse(0, "'hello, world'..");
+    const result = await parser.parse(0, "'hello, world'..", basisLexicon);
 
     // Assert
     expect(result).toHaveProperty("root");
@@ -184,7 +127,7 @@ describe("parser integration tests", () => {
 
   it("should parse numeric literals", async () => {
     // Arrange & Act
-    const result = await parser.parse(0, "42..");
+    const result = await parser.parse(0, "42..", basisLexicon);
 
     // Assert
     expect(result).toHaveProperty("root");
@@ -208,7 +151,7 @@ describe("parser integration tests", () => {
 
   it("should have a PROG node at the root", async () => {
     // Let's test the most basic structure that should always work
-    const result = await parser.parse(0, "123..");
+    const result = await parser.parse(0, "123..", basisLexicon);
 
     // Assert
     expect(result).toHaveProperty("root");
@@ -236,9 +179,8 @@ describe("parser integration tests", () => {
   });
 
   it("should parse complex program: apply (<a b: add a b>) [10 20]..", async () => {
-    // Create parser with custom lexicon
-    const customLexiconCache = new Map();
-    customLexiconCache.set(0, {
+    // Create custom lexicon
+    const customLexicon = {
       add: {
         tk: 2,
         name: "add",
@@ -251,23 +193,10 @@ describe("parser integration tests", () => {
         cls: "function",
         length: 2
       }
-    });
-
-    // Use the parser with our custom cache
-    const customParser = buildParser({
-      log: console.log,
-      cache: customLexiconCache,
-      getLangAsset: async () => ({}),
-      main: {
-        parse: (src, lexicon) => {
-          return Promise.resolve(parser.parse(0, src));
-        }
-      },
-      vm
-    });
+    };
 
     // Act
-    const result = await customParser.parse(0, "apply (<a b: add a b>) [10 20]..");
+    const result = await parser.parse(0, "apply (<a b: add a b>) [10 20]..", customLexicon);
 
     // Assert
     expect(result).toHaveProperty("root");
@@ -327,7 +256,7 @@ describe("parser integration tests", () => {
 
     try {
       // Unclosed string - missing closing quote
-      result = await parser.parse(0, "'unclosed string..");
+      result = await parser.parse(0, "'unclosed string..", basisLexicon);
     } catch (e) {
       // Check for expected error (we should now have a robust parser that doesn't throw)
       console.error("Unexpected error:", e);
@@ -367,7 +296,7 @@ describe("parser integration tests", () => {
 
     try {
       // Missing closing bracket
-      result = await parser.parse(0, "[1, 2, 3..");
+      result = await parser.parse(0, "[1, 2, 3..", basisLexicon);
     } catch (e) {
       console.error("Unexpected error:", e);
       throw e;
@@ -406,7 +335,7 @@ describe("parser integration tests", () => {
 
     try {
       // Invalid sequence of tokens
-      result = await parser.parse(0, "if then else..");
+      result = await parser.parse(0, "if then else..", basisLexicon);
     } catch (e) {
       console.error("Unexpected error:", e);
       throw e;
@@ -441,32 +370,9 @@ describe("parser integration tests", () => {
   });
 
   it("should perform parse-time evaluation for adding two numbers", async () => {
-    // Create parser with custom lexicon that defines 'add' function
-    const customLexiconCache = new Map();
-    customLexiconCache.set(0, {
-      add: {
-        tk: 2,
-        name: "add",
-        cls: "function",
-        length: 2
-      }
-    });
-
-    // Use the parser with our custom cache
-    const customParser = buildParser({
-      log: console.log,
-      cache: customLexiconCache,
-      getLangAsset: async () => ({}),
-      main: {
-        parse: (src, lexicon) => {
-          return Promise.resolve(parser.parse(0, src));
-        }
-      },
-      vm
-    });
-
+    // Use basis lexicon which includes add function
     // Act - parse a simple addition expression
-    const result = await customParser.parse(0, "add 123 456..");
+    const result = await parser.parse(0, "add 123 456..", basisLexicon);
     console.log(
       "TEST",
       "result=" + JSON.stringify(result, null, 2),