shapedef 1.0.19 → 1.0.21

package/src/turing/evaluate.test.ts

@@ -0,0 +1,407 @@
+import { describe, expect } from "vitest";
+import { turing } from "./turing";
+import { createEvalContext, EvalContext, turingEvaluate } from "./evaluate";
+
+const ctx = () => new EvalContext();
+
+describe("turingEvaluate", (it) => {
+  describe("literals", (it) => {
+    it("returns number as-is", () => {
+      expect(turingEvaluate(ctx(), turing.number(42))).toEqual({
+        ok: true,
+        node: turing.number(42),
+      });
+    });
+
+    it("returns str as-is", () => {
+      expect(turingEvaluate(ctx(), turing.str("hello"))).toEqual({
+        ok: true,
+        node: turing.str("hello"),
+      });
+    });
+
+    it("returns bool as-is", () => {
+      expect(turingEvaluate(ctx(), turing.bool(true))).toEqual({
+        ok: true,
+        node: turing.bool(true),
+      });
+    });
+
+    it("returns nil as-is", () => {
+      expect(turingEvaluate(ctx(), turing.nil())).toEqual({
+        ok: true,
+        node: turing.nil(),
+      });
+    });
+
+    it("returns date as-is", () => {
+      const d = new Date("2024-01-01");
+      expect(turingEvaluate(ctx(), turing.date(d))).toEqual({
+        ok: true,
+        node: turing.date(d),
+      });
+    });
+  });
+
+  describe("ref", (it) => {
+    it("resolves a defined variable", () => {
+      const c = createEvalContext({ x: 10 });
+      expect(turingEvaluate(c, turing.ref("x"))).toMatchObject({
+        ok: true,
+        node: turing.number(10),
+      });
+    });
+
+    it("returns error for undefined variable", () => {
+      expect(turingEvaluate(ctx(), turing.ref("missing"))).toMatchObject({
+        ok: false,
+      });
+    });
+  });
+
+  describe("binop: arithmetic", (it) => {
+    it("adds numbers", () => {
+      expect(
+        turingEvaluate(
+          ctx(),
+          turing.binop(turing.number(1), "add", turing.number(2)),
+        ),
+      ).toEqual({ ok: true, node: turing.number(3) });
+    });
+
+    it("concatenates strings with add", () => {
+      expect(
+        turingEvaluate(
+          ctx(),
+          turing.binop(turing.str("foo"), "add", turing.str("bar")),
+        ),
+      ).toEqual({ ok: true, node: turing.str("foobar") });
+    });
+
+    it("rejects add on mismatched types", () => {
+      expect(
+        turingEvaluate(
+          ctx(),
+          turing.binop(turing.number(1), "add", turing.str("x")),
+        ),
+      ).toMatchObject({ ok: false });
+    });
+
+    it("subtracts numbers", () => {
+      expect(
+        turingEvaluate(
+          ctx(),
+          turing.binop(turing.number(10), "sub", turing.number(3)),
+        ),
+      ).toEqual({ ok: true, node: turing.number(7) });
+    });
+
+    it("removes substring with sub", () => {
+      expect(
+        turingEvaluate(
+          ctx(),
+          turing.binop(turing.str("foobar"), "sub", turing.str("bar")),
+        ),
+      ).toEqual({ ok: true, node: turing.str("foo") });
+    });
+
+    it("multiplies numbers", () => {
+      expect(
+        turingEvaluate(
+          ctx(),
+          turing.binop(turing.number(4), "mul", turing.number(3)),
+        ),
+      ).toEqual({ ok: true, node: turing.number(12) });
+    });
+
+    it("divides numbers", () => {
+      expect(
+        turingEvaluate(
+          ctx(),
+          turing.binop(turing.number(10), "div", turing.number(4)),
+        ),
+      ).toEqual({ ok: true, node: turing.number(2.5) });
+    });
+
+    it("computes modulo", () => {
+      expect(
+        turingEvaluate(
+          ctx(),
+          turing.binop(turing.number(10), "mod", turing.number(3)),
+        ),
+      ).toEqual({ ok: true, node: turing.number(1) });
+    });
+
+    it("rejects mul on non-numbers", () => {
+      expect(
+        turingEvaluate(
+          ctx(),
+          turing.binop(turing.str("a"), "mul", turing.str("b")),
+        ),
+      ).toMatchObject({ ok: false });
+    });
+  });
+
+  describe("binop: boolean logic", (it) => {
+    it("and: true && true", () => {
+      expect(
+        turingEvaluate(
+          ctx(),
+          turing.binop(turing.bool(true), "and", turing.bool(true)),
+        ),
+      ).toEqual({ ok: true, node: turing.bool(true) });
+    });
+
+    it("and: true && false", () => {
+      expect(
+        turingEvaluate(
+          ctx(),
+          turing.binop(turing.bool(true), "and", turing.bool(false)),
+        ),
+      ).toEqual({ ok: true, node: turing.bool(false) });
+    });
+
+    it("or: false || true", () => {
+      expect(
+        turingEvaluate(
+          ctx(),
+          turing.binop(turing.bool(false), "or", turing.bool(true)),
+        ),
+      ).toEqual({ ok: true, node: turing.bool(true) });
+    });
+
+    it("or: false || false", () => {
+      expect(
+        turingEvaluate(
+          ctx(),
+          turing.binop(turing.bool(false), "or", turing.bool(false)),
+        ),
+      ).toEqual({ ok: true, node: turing.bool(false) });
+    });
+
+    it("rejects and on non-bools", () => {
+      expect(
+        turingEvaluate(
+          ctx(),
+          turing.binop(turing.number(1), "and", turing.number(0)),
+        ),
+      ).toMatchObject({ ok: false });
+    });
+  });
+
+  describe("binop: equality", (it) => {
+    it("eq: equal numbers", () => {
+      expect(
+        turingEvaluate(
+          ctx(),
+          turing.binop(turing.number(1), "eq", turing.number(1)),
+        ),
+      ).toEqual({ ok: true, node: turing.bool(true) });
+    });
+
+    it("eq: unequal numbers", () => {
+      expect(
+        turingEvaluate(
+          ctx(),
+          turing.binop(turing.number(1), "eq", turing.number(2)),
+        ),
+      ).toEqual({ ok: true, node: turing.bool(false) });
+    });
+
+    it("eq: equal strings", () => {
+      expect(
+        turingEvaluate(
+          ctx(),
+          turing.binop(turing.str("a"), "eq", turing.str("a")),
+        ),
+      ).toEqual({ ok: true, node: turing.bool(true) });
+    });
+
+    it("eq: equal bools", () => {
+      expect(
+        turingEvaluate(
+          ctx(),
+          turing.binop(turing.bool(false), "eq", turing.bool(false)),
+        ),
+      ).toEqual({ ok: true, node: turing.bool(true) });
+    });
+
+    it("eq: equal dates", () => {
+      const d = new Date("2024-06-01");
+      expect(
+        turingEvaluate(
+          ctx(),
+          turing.binop(turing.date(d), "eq", turing.date(new Date(d))),
+        ),
+      ).toEqual({ ok: true, node: turing.bool(true) });
+    });
+
+    it("eq: different types returns false", () => {
+      expect(
+        turingEvaluate(
+          ctx(),
+          turing.binop(turing.number(1), "eq", turing.str("1")),
+        ),
+      ).toEqual({ ok: true, node: turing.bool(false) });
+    });
+
+    it("eq: nil == nil", () => {
+      expect(
+        turingEvaluate(ctx(), turing.binop(turing.nil(), "eq", turing.nil())),
+      ).toEqual({ ok: true, node: turing.bool(true) });
+    });
+
+    it("neq: unequal numbers", () => {
+      expect(
+        turingEvaluate(
+          ctx(),
+          turing.binop(turing.number(1), "neq", turing.number(2)),
+        ),
+      ).toEqual({ ok: true, node: turing.bool(true) });
+    });
+
+    it("neq: equal numbers", () => {
+      expect(
+        turingEvaluate(
+          ctx(),
+          turing.binop(turing.number(5), "neq", turing.number(5)),
+        ),
+      ).toEqual({ ok: true, node: turing.bool(false) });
+    });
+
+    it("neq: different types returns true", () => {
+      expect(
+        turingEvaluate(
+          ctx(),
+          turing.binop(turing.number(1), "neq", turing.str("1")),
+        ),
+      ).toEqual({ ok: true, node: turing.bool(true) });
+    });
+  });
+
+  describe("binop: comparison", (it) => {
+    it("gt: 5 > 3", () => {
+      expect(
+        turingEvaluate(
+          ctx(),
+          turing.binop(turing.number(5), "gt", turing.number(3)),
+        ),
+      ).toEqual({ ok: true, node: turing.bool(true) });
+    });
+
+    it("gt: 3 > 5", () => {
+      expect(
+        turingEvaluate(
+          ctx(),
+          turing.binop(turing.number(3), "gt", turing.number(5)),
+        ),
+      ).toEqual({ ok: true, node: turing.bool(false) });
+    });
+
+    it("gte: 5 >= 5", () => {
+      expect(
+        turingEvaluate(
+          ctx(),
+          turing.binop(turing.number(5), "gte", turing.number(5)),
+        ),
+      ).toEqual({ ok: true, node: turing.bool(true) });
+    });
+
+    it("lt: 2 < 9", () => {
+      expect(
+        turingEvaluate(
+          ctx(),
+          turing.binop(turing.number(2), "lt", turing.number(9)),
+        ),
+      ).toEqual({ ok: true, node: turing.bool(true) });
+    });
+
+    it("lte: 9 <= 9", () => {
+      expect(
+        turingEvaluate(
+          ctx(),
+          turing.binop(turing.number(9), "lte", turing.number(9)),
+        ),
+      ).toEqual({ ok: true, node: turing.bool(true) });
+    });
+
+    it("rejects gt on non-numbers", () => {
+      expect(
+        turingEvaluate(
+          ctx(),
+          turing.binop(turing.str("a"), "gt", turing.str("b")),
+        ),
+      ).toMatchObject({ ok: false });
+    });
+  });
+
+  describe("binop: regex-match", (it) => {
+    it("matches a pattern", () => {
+      expect(
+        turingEvaluate(
+          ctx(),
+          turing.binop(
+            turing.str("hello world"),
+            "regex-match",
+            turing.str("world"),
+          ),
+        ),
+      ).toEqual({ ok: true, node: turing.bool(true) });
+    });
+
+    it("returns false when pattern does not match", () => {
+      expect(
+        turingEvaluate(
+          ctx(),
+          turing.binop(
+            turing.str("hello"),
+            "regex-match",
+            turing.str("^world"),
+          ),
+        ),
+      ).toEqual({ ok: true, node: turing.bool(false) });
+    });
+
+    it("rejects regex-match on non-strings", () => {
+      expect(
+        turingEvaluate(
+          ctx(),
+          turing.binop(turing.number(42), "regex-match", turing.str("\\d+")),
+        ),
+      ).toMatchObject({ ok: false });
+    });
+  });
+
+  describe("nested expressions", (it) => {
+    it("evaluates nested binops", () => {
+      // (2 + 3) * 4 = 20
+      const expr = turing.binop(
+        turing.binop(turing.number(2), "add", turing.number(3)),
+        "mul",
+        turing.number(4),
+      );
+      expect(turingEvaluate(ctx(), expr)).toEqual({
+        ok: true,
+        node: turing.number(20),
+      });
+    });
+
+    it("propagates left-side error", () => {
+      const expr = turing.binop(
+        turing.binop(turing.str("a"), "mul", turing.str("b")),
+        "add",
+        turing.number(1),
+      );
+      expect(turingEvaluate(ctx(), expr)).toMatchObject({ ok: false });
+    });
+
+    it("resolves refs within binop", () => {
+      const c = createEvalContext({ a: 5, b: 3 });
+      const expr = turing.binop(turing.ref("a"), "sub", turing.ref("b"));
+      expect(turingEvaluate(c, expr)).toEqual({
+        ok: true,
+        node: turing.number(2),
+      });
+    });
+  });
+});

package/src/turing/evaluate.ts

@@ -0,0 +1,245 @@
+import { turing, TuringNode } from "./turing";
+
+export class EvalFrame {
+  symbols: Map<string, TuringNode> = new Map();
+
+  constructor(symbols?: Record<string, TuringNode> | Map<string, TuringNode>) {
+    if (symbols) {
+      this.extend(symbols);
+    }
+  }
+
+  extend(symbols: Record<string, TuringNode> | Map<string, TuringNode>) {
+    if (symbols instanceof Map) {
+      for (const [k, v] of Array.from(symbols.entries())) {
+        this.symbols.set(k, v);
+      }
+    } else {
+      for (const [k, v] of Object.entries(symbols)) {
+        this.symbols.set(k, v);
+      }
+    }
+  }
+}
+
+export class EvalContext {
+  frames: EvalFrame[] = [new EvalFrame()];
+
+  get frame(): EvalFrame {
+    if (this.frames.length <= 0) throw new Error("Out of frames");
+    const frame = this.frames[this.frames.length - 1]!;
+    return frame;
+  }
+
+  beginFrame(): EvalFrame {
+    const frame = new EvalFrame();
+    this.frames.push(frame);
+    return frame;
+  }
+
+  endFrame(): EvalFrame {
+    const frame = this.frames.pop() || null;
+    if (!frame) throw new Error("endFrame(): Out of frames");
+    return frame;
+  }
+
+  with<T>(fn: (frame: EvalFrame) => T): T {
+    const frame = this.beginFrame();
+    const r = fn(frame);
+    this.endFrame();
+    return r;
+  }
+}
+
+export const createEvalContext = (
+  vars: Record<string, unknown>,
+): EvalContext => {
+  const ctx = new EvalContext();
+  ctx.frame.extend(
+    Object.assign(
+      {},
+      ...Object.entries(vars).map(([k, v]) => {
+        return { [k]: turing.auto(v) };
+      }),
+    ),
+  );
+  return ctx;
+};
+
+export type EvalResult =
+  | {
+      ok: true;
+      node: TuringNode;
+    }
+  | {
+      ok: false;
+      error: string;
+    };
+
+const ok = (node: TuringNode): Extract<EvalResult, { ok: true }> => ({
+  ok: true,
+  node,
+});
+
+const err = (error: string): Extract<EvalResult, { ok: false }> => ({
+  ok: false,
+  error,
+});
+
+export const turingEvaluate = (
+  ctx: EvalContext,
+  node: TuringNode,
+): EvalResult => {
+  switch (node.type) {
+    case "number":
+    case "date":
+    case "bool":
+    case "nil":
+    case "str":
+      return ok(node);
+    case "ref": {
+      const value = ctx.frame.symbols.get(node.name);
+      if (!value) return err(`Undefined variable: ${node.name}`);
+      return turingEvaluate(ctx, value);
+    }
+    case "binop": {
+      const leftR = turingEvaluate(ctx, node.left);
+      if (!leftR.ok) return leftR;
+      const rightR = turingEvaluate(ctx, node.right);
+      if (!rightR.ok) return rightR;
+
+      const left = leftR.node;
+      const right = rightR.node;
+      const op = node.op;
+
+      switch (op) {
+        case "add": {
+          if (left.type === "number" && right.type === "number")
+            return ok(turing.number(left.value + right.value));
+          if (left.type === "str" && right.type === "str")
+            return ok(turing.str(left.value + right.value));
+          return err(
+            `Invalid operation '${op}' for (${left.type}, ${right.type})`,
+          );
+        }
+        case "sub": {
+          if (left.type === "number" && right.type === "number")
+            return ok(turing.number(left.value - right.value));
+          if (left.type === "str" && right.type === "str")
+            return ok(turing.str(left.value.replace(right.value, "")));
+          return err(
+            `Invalid operation '${op}' for (${left.type}, ${right.type})`,
+          );
+        }
+        case "mul": {
+          if (left.type === "number" && right.type === "number")
+            return ok(turing.number(left.value * right.value));
+          return err(
+            `Invalid operation '${op}' for (${left.type}, ${right.type})`,
+          );
+        }
+        case "div": {
+          if (left.type === "number" && right.type === "number")
+            return ok(turing.number(left.value / right.value));
+          return err(
+            `Invalid operation '${op}' for (${left.type}, ${right.type})`,
+          );
+        }
+        case "mod": {
+          if (left.type === "number" && right.type === "number")
+            return ok(turing.number(left.value % right.value));
+          return err(
+            `Invalid operation '${op}' for (${left.type}, ${right.type})`,
+          );
+        }
+        case "and": {
+          if (left.type === "bool" && right.type === "bool")
+            return ok(turing.bool(left.value && right.value));
+          return err(
+            `Invalid operation '${op}' for (${left.type}, ${right.type})`,
+          );
+        }
+        case "or": {
+          if (left.type === "bool" && right.type === "bool")
+            return ok(turing.bool(left.value || right.value));
+          return err(
+            `Invalid operation '${op}' for (${left.type}, ${right.type})`,
+          );
+        }
+        case "eq": {
+          if (left.type !== right.type) return ok(turing.bool(false));
+          if (left.type === "bool" && right.type === "bool")
+            return ok(turing.bool(left.value === right.value));
+          if (left.type === "number" && right.type === "number")
+            return ok(turing.bool(left.value === right.value));
+          if (left.type === "str" && right.type === "str")
+            return ok(turing.bool(left.value === right.value));
+          if (left.type === "date" && right.type === "date")
+            return ok(
+              turing.bool(left.value.getTime() === right.value.getTime()),
+            );
+          if (left.type === "nil" && right.type === "nil")
+            return ok(turing.bool(left.value === right.value));
+          return err(
+            `Invalid operation '${op}' for (${left.type}, ${right.type})`,
+          );
+        }
+        case "neq": {
+          if (left.type !== right.type) return ok(turing.bool(true));
+          if (left.type === "bool" && right.type === "bool")
+            return ok(turing.bool(left.value !== right.value));
+          if (left.type === "number" && right.type === "number")
+            return ok(turing.bool(left.value !== right.value));
+          if (left.type === "str" && right.type === "str")
+            return ok(turing.bool(left.value !== right.value));
+          if (left.type === "date" && right.type === "date")
+            return ok(
+              turing.bool(left.value.getTime() !== right.value.getTime()),
+            );
+          if (left.type === "nil" && right.type === "nil")
+            return ok(turing.bool(left.value !== right.value));
+          return err(
+            `Invalid operation '${op}' for (${left.type}, ${right.type})`,
+          );
+        }
+        case "gt": {
+          if (left.type === "number" && right.type === "number")
+            return ok(turing.bool(left.value > right.value));
+          return err(
+            `Invalid operation '${op}' for (${left.type}, ${right.type})`,
+          );
+        }
+        case "gte": {
+          if (left.type === "number" && right.type === "number")
+            return ok(turing.bool(left.value >= right.value));
+          return err(
+            `Invalid operation '${op}' for (${left.type}, ${right.type})`,
+          );
+        }
+        case "lt": {
+          if (left.type === "number" && right.type === "number")
+            return ok(turing.bool(left.value < right.value));
+          return err(
+            `Invalid operation '${op}' for (${left.type}, ${right.type})`,
+          );
+        }
+        case "lte": {
+          if (left.type === "number" && right.type === "number")
+            return ok(turing.bool(left.value <= right.value));
+          return err(
+            `Invalid operation '${op}' for (${left.type}, ${right.type})`,
+          );
+        }
+        case "regex-match": {
+          if (left.type === "str" && right.type === "str") {
+            const reg = new RegExp(right.value);
+            return ok(turing.bool(reg.test(left.value)));
+          }
+          return err(
+            `Invalid operation '${op}' for (${left.type}, ${right.type})`,
+          );
+        }
+      }
+    }
+  }
+};

package/src/turing/index.ts

@@ -0,0 +1,3 @@
+export * from "./op";
+export * from "./turing";
+export * from "./evaluate";

package/src/turing/op.ts

@@ -0,0 +1,14 @@
+export type TuringOpCompare =
+  | "eq"
+  | "neq"
+  | "gt"
+  | "gte"
+  | "lt"
+  | "lte"
+  | "regex-match";
+
+export type TuringOpBool = "or" | "and";
+
+export type TuringOpArith = "add" | "sub" | "mul" | "div" | "mod";
+
+export type TuringOp = TuringOpCompare | TuringOpBool | TuringOpArith;