modeling-app/src/lang/executor.test.ts

import fs from "node:fs";

import { abstractSyntaxTree } from "./abstractSyntaxTree";
import { lexer } from "./tokeniser";
import { executor, ProgramMemory } from "./executor";

describe("test", () => {
  it("test assigning two variables, the second summing with the first", () => {
    const code = `const myVar = 5
const newVar = myVar + 1`;
    const { root } = exe(code);
    expect(root.myVar).toBe(5);
    expect(root.newVar).toBe(6);
  });
  it("test assigning a var with a string", () => {
    const code = `const myVar = "a str"`;
    const { root } = exe(code);
    expect(root.myVar).toBe("a str");
  });
  it("test assigning a var by cont concatenating two strings string", () => {
    const code = fs.readFileSync(
      "./src/lang/testExamples/variableDeclaration.cado",
      "utf-8"
    );
    const { root } = exe(code);
    expect(root.myVar).toBe("a str another str");
  });
  it("test with function call", () => {
    const code = `
const myVar = "hello"
log(5, myVar)`;
    const programMemoryOverride = {
      log: jest.fn(),
    };
    const { root } = executor(abstractSyntaxTree(lexer(code)), {
      root: programMemoryOverride,
      _sketch: [],
    });
    expect(root.myVar).toBe("hello");
    expect(programMemoryOverride.log).toHaveBeenCalledWith(5, "hello");
  });
  it("fn funcN = () => {}", () => {
    const { root } = exe(
      [
        "fn funcN = (a, b) => {",
        "  return a + b",
        "}",
        "const theVar = 60",
        "const magicNum = funcN(9, theVar)",
      ].join("\n")
    );
    expect(root.theVar).toBe(60);
    expect(root.magicNum).toBe(69);
  });
  it("sketch declaration", () => {
    let code = `sketch mySketch {
  path myPath = lineTo(0,1)
  lineTo(1,1)
  path rightPath = lineTo(1,0)
  close()
}
show(mySketch)
`;
    const { root, return: _return } = exe(code);
    expect(root.mySketch.map(({ previousPath, ...rest }: any) => rest)).toEqual(
      [
        { type: "base", from: [0, 0] },
        { type: "toPoint", to: [0, 1], name: "myPath" },
        { type: "toPoint", to: [1, 1] },
        { type: "toPoint", to: [1, 0], name: "rightPath" },
        { type: "close", firstPath: { type: "base", from: [0, 0] } },
      ]
    );
    expect(root.mySketch[0]).toEqual(root.mySketch[4].firstPath);
    // hmm not sure what handle the "show" function
    expect(_return).toEqual([
      {
        type: "Identifier",
        start: 108,
        end: 116,
        name: "mySketch",
      },
    ]);
  });
});

// helpers

function exe(
  code: string,
  programMemory: ProgramMemory = { root: {}, _sketch: [] }
) {
  const tokens = lexer(code);
  const ast = abstractSyntaxTree(tokens);
  return executor(ast, programMemory);
}