@valbuild/core 0.25.0 → 0.27.0

package/src/expr/eval.ts

@@ -1,251 +0,0 @@
-/* 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/future";
-import { newSelectorProxy } from "../selector/future/SelectorProxy";
-import { isSerializedVal, SourcePath } from "../val";
-import { Json } from "../Json";
-
-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: (path: string) => Json,
-  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) {
-          const path = expr.children[1].value as SourcePath;
-          return newSelectorProxy(getSource(path), path);
-        } 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) {
-              const path = expr.children[1].value as SourcePath;
-              return newSelectorProxy(getSource(path), path);
-            } 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) => Json,
-  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

@@ -1,91 +0,0 @@
-/* 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

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

package/src/expr/parser.test.ts

@@ -1,158 +0,0 @@
-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);
-      }
-    }
-  );
-});