@valbuild/core 0.12.0 → 0.13.1

package/src/expr/parser.ts

@@ -0,0 +1,229 @@
+import { result } from "../fp";
+import { Call, Expr, StringLiteral, StringTemplate, Sym } from "./expr";
+import { Token, tokenize } from "./tokenizer";
+
+export class ParserError {
+  constructor(
+    public readonly message: string,
+    public readonly span?: [number, number?]
+  ) {}
+}
+
+function parseTokens(inputTokens: Token[]): result.Result<Expr, ParserError> {
+  const tokens = inputTokens.slice();
+
+  function slurpCall(
+    first: Token,
+    isAnon: boolean
+  ): result.Result<Call | Sym, ParserError> {
+    // peek
+    if (
+      (tokens[0]?.type === "ws" && tokens[1]?.type === ")") ||
+      tokens[0]?.type === ")"
+    ) {
+      slurpWs();
+      tokens.shift();
+      return result.ok(new Sym("()", [first.span[0], first.span[1] + 1]));
+    }
+    const args: Expr[] = [];
+    let completed = false;
+    while (!completed) {
+      const res = slurp();
+      if (result.isOk(res)) {
+        args.push(res.value);
+        completed =
+          tokens[0]?.type !== "ws" ||
+          (tokens[0]?.type === "ws" && tokens[1]?.type === ")");
+      } else {
+        return res;
+      }
+    }
+    if (tokens[0]?.type === "ws" && tokens[1]?.type === ")") {
+      tokens.shift();
+    }
+    const last = tokens.shift();
+    if (last?.type !== ")") {
+      return result.err(
+        new ParserError("unbalanced parens: missing a ')'", [
+          first.span[0],
+          first.span[1] + 1,
+        ])
+      );
+    }
+    return result.ok(
+      new Call(args, isAnon, [first.span[0], args.slice(-1)[0].span?.[1] || -1])
+    );
+  }
+
+  function slurpWs() {
+    while (tokens[0]?.type === "ws") {
+      tokens.shift();
+    }
+  }
+
+  function slurpTemplate(
+    first: Token
+  ): result.Result<StringLiteral | StringTemplate, ParserError> {
+    const children: Expr[] = [];
+    while (tokens.length > 0) {
+      if ((tokens[0]?.type as string) === "'") {
+        break;
+      }
+      const nextToken = tokens.shift();
+      if (nextToken?.type === "${") {
+        const res = slurp();
+        if (result.isOk(res)) {
+          children.push(res.value);
+          const last = tokens.shift();
+          if (!last) {
+            return result.err(
+              new ParserError("unbalanced string template: missing a '}'", [
+                first.span[0],
+                children.slice(-1)[0].span?.[1],
+              ])
+            );
+          } else if (last.type !== "}") {
+            return result.err(
+              new ParserError(
+                "unbalanced string template: expected '}'",
+                last.span
+              )
+            );
+          }
+        } else {
+          return res;
+        }
+      } else if (nextToken?.type === "string") {
+        children.push(
+          new StringLiteral(
+            nextToken.unescapedValue || nextToken.value || "",
+            nextToken.span
+          )
+        );
+      }
+    }
+
+    const last = tokens.shift();
+    if (!last) {
+      return result.err(
+        new ParserError("unbalanced string template: missing a '''", [
+          first.span[0],
+          children.slice(-1)[0].span?.[1],
+        ])
+      );
+    } else if (last.type !== "'") {
+      return result.err(
+        new ParserError("unbalanced string template: expected '''", last.span)
+      );
+    }
+
+    return result.ok(
+      new StringTemplate(children, [first.span[0], last.span[1]])
+    );
+  }
+
+  function slurpString(
+    first: Token
+  ): result.Result<StringLiteral | StringTemplate, ParserError> {
+    if (tokens[0]?.type === "string" && tokens[1]?.type === "'") {
+      const stringToken = tokens.shift();
+      const last = tokens.shift();
+      if (!last || !stringToken) {
+        throw Error("Unexpected error: stringToken or last is undefined");
+      }
+      return result.ok(
+        new StringLiteral(
+          stringToken.unescapedValue || stringToken.value || "",
+          [first.span[0], last.span[1]]
+        )
+      );
+    } else if (tokens[0]?.type === "'") {
+      const last = tokens.shift();
+      if (!last) {
+        throw Error("Unexpected error: last is undefined");
+      }
+      return result.ok(new StringLiteral("", [first.span[0], last.span[1]]));
+    } else {
+      return slurpTemplate(first);
+    }
+  }
+
+  function slurp(): result.Result<Expr, ParserError> {
+    slurpWs();
+    const first = tokens.shift();
+    if (!first) {
+      return result.err(
+        new ParserError("expected '(', '!(', string or literal", [0, 0])
+      );
+    }
+    if (first.type === "(" || first.type === "!(") {
+      return slurpCall(first, first.type === "!(");
+    } else if (first.type === "'") {
+      return slurpString(first);
+    } else if (first.type === "token") {
+      if (first.value?.includes("(") || first.value?.includes(")")) {
+        return result.err(
+          new ParserError(
+            "unexpected token: '(' and ')' are not allowed in tokens",
+            first.span
+          )
+        );
+      }
+      if (first.value?.includes("'")) {
+        return result.err(
+          new ParserError(
+            'unexpected token: "\'" is not allowed in tokens',
+            first.span
+          )
+        );
+      }
+      if (first.value?.includes(".")) {
+        return result.err(
+          new ParserError(
+            'unexpected token: "." is not allowed in tokens',
+            first.span
+          )
+        );
+      }
+      if (first.value?.includes("{") || first.value?.includes("}")) {
+        return result.err(
+          new ParserError(
+            "unexpected token: '{' and '}' are not allowed in tokens",
+            first.span
+          )
+        );
+      }
+      return result.ok(new Sym(first.value || "", first.span));
+    } else {
+      return result.err(
+        new ParserError(
+          `expected '(', '!(' or literal or token${
+            first.value || first.type
+              ? `, got: '${first.value || first.type}'`
+              : ""
+          }`,
+          first.span
+        )
+      );
+    }
+  }
+  const res = slurp();
+  slurpWs();
+  if (result.isErr(res)) {
+    return res;
+  }
+  if (tokens.length > 0) {
+    return result.err(
+      new ParserError("expected end of input, superfluous tokens", [
+        tokens[0].span[0],
+        tokens.slice(-1)[0].span[1],
+      ])
+    );
+  }
+  return res;
+}
+export function parse(input: string): result.Result<Expr, ParserError> {
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  const [tokens, cursor] = tokenize(input); // TODO: we can use cursor to improve error messages / spans
+  return parseTokens(tokens);
+}

package/src/expr/repl.ts

@@ -0,0 +1,93 @@
+import * as repl from "repl";
+import { result, pipe } from "../../fp";
+import { newSelectorProxy, selectorToVal } from "../selector/SelectorProxy";
+import { SourcePath } from "../val";
+import { evaluate } from "./eval";
+import { parse } from "./parser";
+
+const sources = {
+  "/app/text": "text1",
+  "/numbers": [1, 2, 3],
+  "/blogs": [
+    { title: "title1", text: "text1" },
+    { title: "title2", text: "text2" },
+  ],
+};
+
+repl
+  .start({
+    prompt: "β > ",
+    eval: (
+      cmd,
+      context,
+      filename,
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      callback: (arg0: any, arg1: any) => void
+    ) => {
+      const res = parse(cmd);
+      if (result.isErr(res)) {
+        let lines = "\n\x1b[31m";
+        lines +=
+          res.error.message[0]?.toUpperCase() +
+          res.error.message.slice(1) +
+          ` (${res.error.span?.[0]}:${res.error.span?.[1]})` +
+          ":\x1b[0m\n\n";
+        lines += cmd + "\n";
+        let underline = "\x1b[31m";
+        for (let i = 0; i < cmd.length; i++) {
+          if (
+            res.error.span &&
+            i >= res.error.span[0] &&
+            i <= (res.error.span?.[1] === undefined ? -1 : res.error.span?.[1])
+          ) {
+            underline += "^";
+          } else {
+            if (cmd[i] === "\n") {
+              if (!underline.includes("^")) {
+                underline = "";
+              }
+            } else {
+              underline += " ";
+            }
+          }
+        }
+        lines += underline + "\x1b[0m\n";
+        callback(null, lines);
+      } else {
+        pipe(
+          evaluate(
+            res.value,
+            (ref) =>
+              newSelectorProxy(
+                sources[ref as keyof typeof sources],
+                ref as SourcePath
+              ),
+
+            []
+          ),
+          result.map((v) => {
+            try {
+              console.log(selectorToVal(v).val);
+              callback(null, undefined);
+            } catch (e) {
+              callback(
+                null,
+                `\x1b[31mInvalid function! Expected selector, but got:\x1b[0m:\n${JSON.stringify(
+                  v
+                )}\n\nDetails: ${
+                  e instanceof Error ? e.message : JSON.stringify(e)
+                }`
+              );
+            }
+          })
+        );
+      }
+    },
+    ignoreUndefined: true,
+    writer: (output) => {
+      return output;
+    },
+  })
+  .setupHistory(".repl_history", () => {
+    //
+  });