@valbuild/core 0.12.0 → 0.13.1

package/src/expr/eval.ts

@@ -0,0 +1,248 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { Call, Expr, StringLiteral, StringTemplate, Sym } from "./expr";
+import { Source } from "../source";
+import { result } from "../fp";
+import { Path, SourceOrExpr } from "../selector";
+import { newSelectorProxy } from "../selector/SelectorProxy";
+import { isSerializedVal, SourcePath } from "../val";
+
+export class EvalError {
+  constructor(public readonly message: string, public readonly expr: Expr) {}
+
+  toString() {
+    return `${this.message} in: ${this.expr.transpile()}`;
+  }
+}
+
+type LocalSelector<S extends Source> = {
+  readonly [key: string | number]:
+    | LocalSelector<Source>
+    | ((...args: any[]) => any);
+} & {
+  [SourceOrExpr]: S;
+  [Path]: SourcePath | undefined;
+};
+
+const MAX_STACK_SIZE = 100; // an arbitrary semi-large number
+function evaluateSync(
+  expr: Expr,
+  getSource: (ref: string) => LocalSelector<Source>,
+  stack: readonly LocalSelector<Source>[][]
+): LocalSelector<Source> {
+  // TODO: amount of evaluates should be limited?
+  if (stack.length > MAX_STACK_SIZE) {
+    throw new EvalError(
+      `Stack overflow. Final frames: ${stack
+        .slice(-10)
+        .map((frame, i) =>
+          frame.map((s, j) => `@[${i},${j}]: ${JSON.stringify(s)}`).join(", ")
+        )
+        .join(" -> ")}`,
+      expr
+    );
+  }
+  if (expr instanceof Call) {
+    if (expr.children[0] instanceof Sym) {
+      if (expr.children[0].value === "val") {
+        if (expr.isAnon) {
+          throw new EvalError("cannot call 'val' as anonymous function", expr);
+        }
+        if (expr.children[1] instanceof StringLiteral) {
+          return getSource(expr.children[1].value);
+        } else {
+          throw new EvalError(
+            "argument of 'val' must be a string literal",
+            expr
+          );
+        }
+      } else if (expr.children[0].value === "json") {
+        if (expr.children.length !== 2) {
+          throw new EvalError(
+            "must call 'json' with exactly one argument",
+            expr
+          );
+        }
+        const value = evaluateSync(expr.children[1], getSource, stack);
+
+        const valObj = value[SourceOrExpr];
+        const valPath = value[Path];
+        if (typeof valObj !== "string") {
+          throw new EvalError(
+            `cannot parse JSON: ${JSON.stringify(valObj)}, expected string`,
+            expr.children[1]
+          );
+        }
+        try {
+          const serialized = JSON.parse(valObj);
+          if (isSerializedVal(serialized)) {
+            return newSelectorProxy(serialized.val, serialized.valPath);
+          }
+          const parsedValue = newSelectorProxy(JSON.parse(valObj), valPath);
+          return parsedValue;
+        } catch (e) {
+          if (e instanceof SyntaxError) {
+            throw new EvalError(
+              `cannot parse JSON: ${valObj}, ${
+                e.message
+              } - value: ${JSON.stringify(value)}`,
+              expr.children[1]
+            );
+          }
+          throw e;
+        }
+      } else if (expr.children[0].value === "stringify") {
+        // TODO: remove stringify
+        if (expr.children.length !== 2) {
+          throw new EvalError(
+            "must call 'stringify' with exactly one argument",
+            expr
+          );
+        }
+        const res = evaluateSync(expr.children[1], getSource, stack);
+        return newSelectorProxy(JSON.stringify(res[SourceOrExpr]));
+      }
+    }
+    const prop = evaluateSync(expr.children[0], getSource, stack)[SourceOrExpr];
+    if (expr.children.length === 1) {
+      // TODO: return if literal only?
+      return newSelectorProxy(prop);
+    }
+    const obj = evaluateSync(expr.children[1], getSource, stack);
+    if (typeof prop !== "string" && typeof prop !== "number") {
+      throw new EvalError(
+        `cannot access ${JSON.stringify(obj)} with property ${JSON.stringify(
+          prop
+        )}: is not a string or number`,
+        expr
+      );
+    }
+
+    if (prop in obj) {
+      if (expr.isAnon) {
+        // anon functions:
+        const maybeFunction = obj[prop];
+        if (typeof maybeFunction !== "function") {
+          throw new EvalError(
+            `cannot access property ${JSON.stringify(prop)} of ${JSON.stringify(
+              obj
+            )}: required higher ordered function got ${typeof obj[prop]}`,
+            expr
+          );
+        }
+        if (expr.children[0] instanceof Sym) {
+          return maybeFunction((...args: any[]) => {
+            return evaluateSync(
+              expr.children[2],
+              getSource,
+              stack.concat([args])
+            );
+          });
+        } else {
+          throw new EvalError(
+            `cannot call an expression that is not a symbol, got: '${expr.children[0].type}'`,
+            expr
+          );
+        }
+      } else {
+        // non-anon functions:
+        if (expr.children[0] instanceof Sym) {
+          if (expr.children[0].value === "val") {
+            if (expr.children[1] instanceof StringLiteral) {
+              return getSource(expr.children[1].value);
+            } else {
+              throw new EvalError(
+                "argument of 'val' must be a string literal",
+                expr
+              );
+            }
+          }
+        }
+        const args = expr.children.slice(2);
+        if (args.length > 0) {
+          const maybeFunction = obj[prop];
+          if (typeof maybeFunction !== "function") {
+            throw new EvalError(
+              `cannot access property ${JSON.stringify(
+                prop
+              )} of ${JSON.stringify(obj)}: required function got ${typeof obj[
+                prop
+              ]}`,
+              expr
+            );
+          }
+          return maybeFunction(
+            ...args.map((arg) => evaluateSync(arg, getSource, stack))
+          );
+        }
+        const maybeValue = obj[prop];
+        if (typeof maybeValue === "function") {
+          throw new EvalError(
+            `cannot access property ${JSON.stringify(prop)} of ${JSON.stringify(
+              obj
+            )}: required value got ${typeof obj[prop]}`,
+            expr
+          );
+        }
+        return maybeValue;
+      }
+    }
+  } else if (expr instanceof Sym) {
+    if (expr.value.startsWith("@")) {
+      const [i, j, rest] = expr.value.slice(2, -1).split(",");
+      if (rest) {
+        throw new EvalError(`cannot access stack: too many indices`, expr);
+      }
+      const stackValue = stack[Number(i)]?.[Number(j)];
+      if (stackValue === undefined) {
+        throw new EvalError(`cannot access stack: out of bounds`, expr);
+      }
+      return stackValue;
+    } else if (expr.value === "()") {
+      return newSelectorProxy(null);
+    }
+    return newSelectorProxy(expr.value);
+  } else if (expr instanceof StringLiteral) {
+    return newSelectorProxy(expr.value);
+  } else if (expr instanceof StringTemplate) {
+    return newSelectorProxy(
+      expr.children
+        .map((child) => {
+          if (child instanceof Sym && child.value === "()") {
+            return "null";
+          }
+          const evalRes = evaluateSync(child, getSource, stack);
+          if (
+            child.type === "StringLiteral" ||
+            child.type === "StringTemplate"
+          ) {
+            return evalRes[SourceOrExpr];
+          }
+          if (Path in evalRes) {
+            // a selector, so serialize to Val
+            return JSON.stringify({
+              val: evalRes[SourceOrExpr],
+              valPath: evalRes[Path],
+            });
+          }
+          return JSON.stringify(evalRes[SourceOrExpr]);
+        })
+        .join("")
+    );
+  }
+  throw new EvalError(`could not evaluate`, expr);
+}
+
+export function evaluate(
+  expr: Expr,
+  source: (ref: string) => LocalSelector<Source>,
+  stack: readonly LocalSelector<Source>[][]
+): result.Result<LocalSelector<Source>, EvalError> {
+  try {
+    return result.ok(evaluateSync(expr, source, stack));
+  } catch (err) {
+    if (err instanceof EvalError) {
+      return result.err(err);
+    }
+    throw err;
+  }
+}

package/src/expr/expr.ts

@@ -0,0 +1,91 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+
+export abstract class Expr {
+  abstract type: "StringLiteral" | "Sym" | "StringTemplate" | "Call";
+  abstract transpile(): string;
+  constructor(public readonly span?: [number, number?]) {}
+}
+
+export class StringLiteral extends Expr {
+  public type = "StringLiteral" as const;
+  constructor(
+    public readonly value: string,
+    span?: [start: number, stop: number]
+  ) {
+    super(span);
+  }
+
+  transpile() {
+    return `'${this.value}'`;
+  }
+}
+
+export class Sym extends Expr {
+  public type = "Sym" as const;
+  constructor(
+    public readonly value: string,
+    span?: [start: number, stop: number]
+  ) {
+    super(span);
+  }
+
+  transpile() {
+    return this.value;
+  }
+}
+
+export const NilSym = new Sym("()");
+
+export class StringTemplate extends Expr {
+  public type = "StringTemplate" as const;
+  constructor(
+    public readonly children: readonly Expr[],
+    span?: [number, number]
+  ) {
+    super(span);
+  }
+
+  transpile() {
+    return `'${this.children
+      .map((child) => {
+        if (child instanceof StringLiteral) {
+          return child.value;
+        } else {
+          return `\${${child.transpile()}}`;
+        }
+      })
+      .join("")}'`;
+  }
+}
+
+export class Call extends Expr {
+  public type = "Call" as const;
+  constructor(
+    public readonly children: readonly Expr[],
+    public readonly isAnon: boolean,
+    span?: [number, number]
+  ) {
+    super(span);
+  }
+
+  transpile() {
+    if (this.isAnon) {
+      return `!(${this.children.map((child) => child.transpile()).join(" ")})`;
+    }
+    return `(${this.children.map((child) => child.transpile()).join(" ")})`;
+  }
+}
+
+// export function interpret(
+//   expr: SExpr,
+//   moduleId: string,
+//   schemas: {
+//     [moduleId: string]: Schema<Source>;
+//   },
+//   getSource: (moduleId: string) => Promise<Source>
+// ) {}
+
+// TODO: use this instead of including the unescaped strings in the parser
+function escapeString(str: string) {
+  return str.replace(/\\/g, "\\\\");
+}

package/src/expr/index.ts

@@ -0,0 +1,3 @@
+export { parse } from "./parser";
+export { Call, Expr, NilSym, StringLiteral, StringTemplate, Sym } from "./expr";
+export { evaluate } from "./eval";

package/src/expr/parser.test.ts

@@ -0,0 +1,158 @@
+import { result } from "../../fp";
+import { parse } from "./parser";
+
+const ParserTestCases: {
+  input: string;
+  error?: {
+    span: [start: number, stop: number];
+  };
+  overrideTest?: string;
+}[] = [
+  {
+    input: "!(",
+    error: {
+      span: [0, 0],
+    },
+  },
+  {
+    input: "')'",
+  },
+  {
+    input: "(",
+    error: {
+      span: [0, 0],
+    },
+  },
+  {
+    input: "()",
+  },
+  {
+    input: " (  ) ",
+    overrideTest: "()",
+  },
+  {
+    input: "(reverse foo ())",
+  },
+  {
+    input: "(b ab)", // single character tokens
+  },
+  {
+    input: "!(map fn value)",
+  },
+  {
+    input: "!(map (map foo bar) value)",
+  },
+  {
+    input: "'foo'",
+  },
+  // this is the JS equivalent: 'f\'oo'
+  {
+    input: "'f\\'oo'",
+  },
+  // lenient tokenization (errors must handled by the parser)
+  // this is the JS equivalent: 'f\\'oofail'
+  {
+    input: "'f\\\\'oo'fail",
+    error: {
+      span: [5, 11],
+    },
+  },
+  {
+    input: "(fo() (fail zoo))",
+    error: {
+      span: [1, 3], // this would preferably be [1, 4]
+    },
+  },
+  // this is the JS equivalent: 'f\\\'oo'
+  {
+    input: "'f\\\\\\'oo'",
+  },
+  {
+    input: "(foo (bar zoo))",
+  },
+  {
+    input: "  (foo (bar 'he\\'pp'   zoo))  ",
+    overrideTest: "(foo (bar 'he\\'pp' zoo))",
+  },
+  {
+    input: "''",
+  },
+  //interpolation:
+  {
+    input: "'${'str'}'",
+    overrideTest: "'str'",
+  },
+  {
+    input: "'${'${(foo bar)}'}'",
+  },
+  {
+    input: "'foo${(bar baz)}'",
+  },
+  {
+    input: "'${'foo ${(foo bar)}'}'",
+  },
+  {
+    input: "'${'${'${(foo bar)}'}'}'",
+  },
+  {
+    input: `(json '{"foo": "bar"}')`,
+  },
+  {
+    input: `(json '{"foo": \${(foo bar)}}')`,
+  },
+  {
+    input: `(json '{"foo": \${(foo bar)}, "baz": "baz"}')`,
+  },
+  {
+    input: `!(map 'title' )`,
+    overrideTest: `!(map 'title')`,
+  },
+  {
+    input: `!(map
+      (ref '/foo/bar')
+      ('title' @0)
+    )`,
+    overrideTest: `!(map (ref '/foo/bar') ('title' @0))`,
+  },
+];
+
+describe("parser", () => {
+  test.each(ParserTestCases)(
+    'expr: "$input"',
+    ({ input, error, overrideTest }) => {
+      const res = parse(input);
+      if (error) {
+        if (result.isErr(res)) {
+          expect(res.error.span).toEqual(error.span);
+        } else {
+          expect(res).toHaveProperty("error");
+        }
+      } else if (result.isErr(res)) {
+        process.stdout.write(res.error.message + ":\n\n");
+        process.stdout.write(input + "\n");
+        let underline = "";
+        for (let i = 0; i < input.length; i++) {
+          if (
+            res.error.span &&
+            i >= res.error.span[0] &&
+            i <= (res.error.span?.[1] || -1)
+          ) {
+            underline += "^";
+          } else {
+            if (input[i] === "\n") {
+              if (!underline.includes("^")) {
+                underline = "";
+              }
+            } else {
+              underline += " ";
+            }
+          }
+        }
+        process.stderr.write(underline + "\n");
+        expect(res).toHaveProperty("value");
+      } else {
+        expect(res.value.transpile()).toBe(overrideTest || input);
+      }
+    }
+  );
+});