@graffiticode/parser 0.1.0 → 0.1.1

package/src/{parser.js~ → parser.ts~}

@@ -1,10 +1,28 @@
 import vm from "vm";
-import { getLangAsset } from "../../../api/src/lang/index.js";
-import { parse } from "./parse.js";
+import { getLangAsset } from "../../api/src/lang/index.js";
+// Import parse module
+import parse from "./parse";
+
+// Define interfaces
+interface ParserOptions {
+  log: (message: string, ...args: any[]) => void;
+  cache: Map<string, any>;
+  getLangAsset: (lang: string, path: string) => Promise<any>;
+  main: MainParser;
+  vm: typeof vm;
+}
+
+interface MainParser {
+  parse: (src: string, lexicon: any) => any;
+}
+
+interface Parser {
+  parse: (lang: string, src: string) => Promise<any>;
+}
 
 // commonjs export
-const main = {
-  parse(src, lexicon) {
+const main: MainParser = {
+  parse(src: string, lexicon: any) {
     const stream = new parse.StringStream(src);
     const state = {
       cc: parse.program, // top level parsing function
@@ -49,9 +67,9 @@ export const buildParser = ({
   getLangAsset,
   main,
   vm
-}) => {
+}: ParserOptions): Parser => {
   return {
-    async parse(lang, src) {
+    async parse(lang: string, src: string) {
       if (!cache.has(lang)) {
         let data = await getLangAsset(lang, "/lexicon.js");
         // TODO Make lexicon JSON.
@@ -69,7 +87,7 @@ export const buildParser = ({
         } catch (err) {
           if (err instanceof SyntaxError) {
             log(`failed to parse ${lang} lexicon: ${err.message}`);
-            const context = { window: { gcexports: {} } };
+            const context = { window: { gcexports: { globalLexicon: null } } };
             vm.createContext(context);
             vm.runInContext(data, context);
             if (typeof (context.window.gcexports.globalLexicon) === "object") {

package/src/stringstream.js

@@ -0,0 +1,22 @@
+export class StringStream {
+  constructor(string, tabSize = 2) {
+    this.pos = 0;
+    this.start = 0;
+    this.string = string;
+    this.tabSize = tabSize;
+  }
+
+  peek() {
+    return this.string.charAt(this.pos) || undefined;
+  }
+
+  next() {
+    if (this.pos < this.string.length) {
+      return this.string.charAt(this.pos++);
+    }
+  }
+
+  backUp(n) {
+    this.pos -= n;
+  }
+}

package/src/fold.js

@@ -1,235 +0,0 @@
-import assert from "assert";
-import { Ast, env } from "./parse.js";
-
-export const folder = (function () {
-  const table = {
-    PROG: program,
-    EXPRS: exprs,
-    PAREN: parenExpr,
-    IDENT: ident,
-    BOOL: bool,
-    NUM: num,
-    STR: str,
-    PARENS: unaryExpr,
-    APPLY: apply,
-    LAMBDA: lambda,
-    // "MUL": mul,
-    // "DIV": div,
-    // "SUB": sub,
-    ADD: add,
-    POW: pow,
-    MOD: mod,
-    CONCAT: concat,
-    // "OR": orelse,
-    // "AND": andalso,
-    // "NE": ne,
-    // "EQ": eq,
-    // "LT": lt,
-    // "GT": gt,
-    // "LE": le,
-    // "GE": ge,
-    NEG: neg,
-    LIST: list
-    // "CASE": caseExpr,
-    // "OF": ofClause,
-  };
-
-  let nodePool;
-  let ctx;
-
-  function fold(cx, nid) {
-    ctx = cx;
-    nodePool = ctx.state.nodePool;
-    visit(nid);
-  }
-
-  function visit(nid) {
-    const node = nodePool[nid];
-    if (!node) {
-      return null;
-    }
-    if (node.tag === undefined) {
-      return []; // clean up stubs;
-    } else if (isFunction(table[node.tag])) {
-      // Have a primitive operation so apply it to construct a new node.
-      const ret = table[node.tag](node);
-      return ret;
-    }
-    expr(node);
-  }
-
-  function isFunction(v) {
-    return v instanceof Function;
-  }
-
-  // BEGIN VISITOR METHODS
-
-  function program(node) {
-    visit(node.elts[0]);
-    Ast.program(ctx);
-  }
-
-  function pushNodeStack(ctx) {
-    ctx.state.nodeStackStack.push(ctx.state.nodeStack);
-    ctx.state.nodeStack = [];
-  }
-  function popNodeStack(ctx) {
-    const stack = ctx.state.nodeStack;
-    ctx.state.nodeStack = ctx.state.nodeStackStack.pop().concat(stack);
-  }
-
-  function list(node) {
-    // Fold list
-    // for (var i = 0; i < node.elts.length; i++) {
-    //   visit(node.elts[i]);
-    // }
-    pushNodeStack(ctx);
-    for (let i = node.elts.length - 1; i >= 0; i--) {
-      visit(node.elts[i]); // Keep original order.
-    }
-    Ast.list(ctx, ctx.state.nodeStack.length, null, true);
-    popNodeStack(ctx);
-  }
-
-  function exprs(node) {
-    // Fold exprs in reverse order to get precedence right.
-    for (let i = node.elts.length - 1; i >= 0; i--) {
-      visit(node.elts[i]); // Keep original order.
-    }
-    ctx.state.exprc = node.elts.length;
-  }
-
-  function lambda(node) {
-    // Fold initializers and apply args.
-    const inits = Ast.node(ctx, node.elts[3]).elts;
-    inits.forEach((init, i) => {
-      if (init) {
-        // If we have an init then fold it and replace in inits list.
-        folder.fold(ctx, Ast.intern(ctx, init));
-        inits[i] = Ast.pop(ctx);
-      }
-    });
-    // FIXME don't patch old node. construct a new one.
-    node.elts[3] = Ast.intern(ctx, { tag: "LIST", elts: inits });
-    const fnId = Ast.intern(ctx, node);
-    const argc = ctx.state.nodeStack.length;
-    Ast.apply(ctx, fnId, argc);
-  }
-
-  function apply(node) {
-    for (let i = node.elts.length - 1; i >= 0; i--) {
-      visit(node.elts[i]);
-    }
-    Ast.applyLate(ctx, node.elts.length);
-  }
-
-  function expr(node) {
-    // Construct an expression node for the compiler.
-    Ast.name(ctx, node.tag);
-    for (let i = node.elts.length - 1; i >= 0; i--) {
-      visit(node.elts[i]);
-    }
-    Ast.expr(ctx, node.elts.length);
-  }
-
-  function neg(node) {
-    visit(node.elts[0]);
-    Ast.neg(ctx);
-  }
-
-  function parenExpr(node) {
-    pushNodeStack(ctx);
-    visit(node.elts[0]);
-    Ast.parenExpr(ctx);
-    popNodeStack(ctx);
-  }
-
-  function unaryExpr(node) {
-    visit(node.elts[0]);
-    Ast.unaryExpr(ctx, node.tag);
-  }
-
-  function add(node) {
-    visit(node.elts[0]);
-    visit(node.elts[1]);
-    Ast.add(ctx);
-  }
-
-  function pow(node) {
-    visit(node.elts[0]);
-    visit(node.elts[1]);
-    Ast.pow(ctx);
-  }
-
-  function concat(node) {
-    visit(node.elts[0]);
-    Ast.concat(ctx);
-  }
-
-  function mod(node) {
-    visit(node.elts[0]);
-    visit(node.elts[1]);
-    Ast.mod(ctx);
-  }
-
-  function ident(node) {
-    const name = node.elts[0];
-    const word = env.findWord(ctx, name);
-    if (word) {
-      if (word.cls === "val") {
-        if (word.val) {
-          Ast.string(ctx, word.val); // strip quotes;
-        } else if (word.nid) {
-          let wrd;
-          if ((wrd = Ast.node(ctx, word.nid)).tag === "LAMBDA") {
-            const argc = wrd.elts[0].elts.length;
-            Ast.apply(ctx, word.nid, argc);
-          } else {
-            Ast.push(ctx, word.nid);
-          }
-        } else if (word.name) {
-          Ast.push(ctx, node);
-        } else {
-          // push the original node to be resolved later.
-          Ast.push(ctx, node);
-        }
-      } else if (word.cls === "function") {
-        const elts = [];
-        for (let i = 0; i < word.length; i++) {
-          const elt = Ast.pop(ctx);
-          elts.push(elt);
-        }
-        if (word.nid) {
-          Ast.fold(ctx, word, elts);
-        } else {
-          Ast.push(ctx, {
-            tag: word.name,
-            elts
-          });
-          folder.fold(ctx, Ast.pop(ctx));
-        }
-      } else {
-        assert(false);
-      }
-    } else {
-      // assert(false, "unresolved ident "+name);
-      Ast.push(ctx, node);
-    }
-  }
-
-  function num(node) {
-    Ast.number(ctx, node.elts[0]);
-  }
-
-  function str(node) {
-    Ast.string(ctx, node.elts[0]);
-  }
-
-  function bool(node) {
-    Ast.bool(ctx, node.elts[0]);
-  }
-
-  return {
-    fold
-  };
-}());

package/src/parser.spec.js~

@@ -1,175 +0,0 @@
-import { jest } from "@jest/globals";
-import { parser, buildParser } from "./parser.js";
-import { mockPromiseValue, mockPromiseError } from "../testing/index.js";
-
-describe("lang/parser", () => {
-  const log = jest.fn();
-  it("should call main parser language lexicon", async () => {
-    // Arrange
-    const cache = new Map();
-    const getLangAsset = mockPromiseValue("{}");
-    const main = {
-      parse: mockPromiseValue({ root: "0" })
-    };
-    const parser = buildParser({ log, cache, getLangAsset, main });
-    const lang = "0";
-    const src = "'foo'..";
-
-    // Act
-    await expect(parser.parse(lang, src)).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({});
-  });
-  it("should call main parser cached lexicon", async () => {
-    // Arrange
-    const cache = new Map();
-    const main = {
-      parse: mockPromiseValue({ root: "0" })
-    };
-    const parser = buildParser({
-      cache,
-      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");
-  });
-  it("should return error if main parser fails", 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 lang = "0";
-    const src = "'foo'..";
-
-    // Act
-    await expect(parser.parse(lang, src)).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({});
-  });
-  it("should return succeed if lexicon is a buffer", 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 src = "'foo'..";
-
-    // Act
-    await expect(parser.parse(lang, src)).resolves.toStrictEqual(ast);
-
-    // Assert
-    expect(getLangAsset).toHaveBeenCalledWith(lang, "/lexicon.js");
-    expect(main.parse).toHaveBeenCalledWith(src, {});
-    expect(cache.has(lang)).toBe(true);
-    expect(cache.get(lang)).toStrictEqual({});
-  });
-  it("should try vm if lexicon cannot parse JSON", 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 lang = "0";
-    const src = "'foo'..";
-
-    // Act
-    await expect(parser.parse(lang, src)).resolves.toStrictEqual(ast);
-
-    // 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());
-  });
-  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 () => {
-    const lang = "0";
-    const src = "'hello, world'";
-    await expect(parser.parse(lang, src)).rejects.toThrow("End of program reached");
-  });
-  // 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");
-  // });
-});