tarsec 0.0.1

package/.github/workflows/node.js.yml

@@ -0,0 +1,31 @@
+# This workflow will do a clean installation of node dependencies, cache/restore them, build the source code and run tests across different versions of node
+# For more information see: https://docs.github.com/en/actions/automating-builds-and-tests/building-and-testing-nodejs
+
+name: Node.js CI
+
+on:
+  push:
+    branches: [ "main" ]
+  pull_request:
+    branches: [ "main" ]
+
+jobs:
+  build:
+
+    runs-on: ubuntu-latest
+
+    strategy:
+      matrix:
+        node-version: [16.x, 18.x]
+        # See supported Node.js release schedule at https://nodejs.org/en/about/releases/
+
+    steps:
+    - uses: actions/checkout@v3
+    - name: Use Node.js ${{ matrix.node-version }}
+      uses: actions/setup-node@v3
+      with:
+        node-version: ${{ matrix.node-version }}
+        cache: 'npm'
+    - run: npm install
+    - run: npm run build --if-present
+    - run: npm test

package/README.md

@@ -0,0 +1,64 @@
+```
+ __
+/\ \__
+\ \ ,_\    __     _ __   ____     __    ___
+ \ \ \/  /'__`\  /\`'__\/',__\  /'__`\ /'___\
+  \ \ \_/\ \L\.\_\ \ \//\__, `\/\  __//\ \__/
+   \ \__\ \__/.\_\\ \_\\/\____/\ \____\ \____\
+    \/__/\/__/\/_/ \/_/ \/___/  \/____/\/____/
+```
+
+A parser combinator library for TypeScript, inspired by Parsec.
+
+## Install
+
+```
+npm install egonSchiele/tarsec
+```
+
+## Hello world
+
+```ts
+// define a parser
+const parser = seq([
+    str("hello"),
+    space,
+    str("world")
+]);
+
+// then use it
+parser("hello world"); // success
+parser("hello there"); // failure
+```
+
+## A longer example
+
+```ts
+// define a parser to parse "hello, <name>!"
+const parser = seq([
+    str("hello"),
+    space,
+
+    /*
+    
+    Capture group to capture the name.
+    
+    `many1(noneOf("!"))` parses one or more characters
+    that are not an exclamation mark.
+    `many1` returns an array of characters,
+    `many1WithJoin` joins them into a string.
+    
+    This capture group is then given the name "person".
+    
+    */
+    capture(many1WithJoin(noneOf("!")), "person"),
+    char("!"),
+]);
+
+// parse
+const result = parser("hello adit!");
+
+console.log(result.success); // true
+console.log(result.captures); // { person: "adit" }
+```
+

package/TODOS.md

@@ -0,0 +1,5 @@
+- tests
+- docs
+- ci
+- better perf
+- package for npm

package/index.ts

@@ -0,0 +1,105 @@
+import {
+  seq,
+  capture,
+  many1WithJoin,
+  many,
+  optional,
+  or,
+  manyWithJoin,
+  transform,
+  many1,
+  captureCaptures,
+  shapeCaptures,
+} from "./lib/combinators.js";
+import {
+  noneOf,
+  space,
+  str,
+  char,
+  quote,
+  word,
+  quotedString,
+} from "./lib/parsers.js";
+/* 
+const helloParser = seq<any, "name">([
+  str("hello"),
+  space,
+  capture<string, "name">(many1WithJoin(noneOf("!")), "name"),
+  char("!"),
+]);
+
+const questionParser = seq<any, "question">([
+  capture<string, "question">(many1WithJoin(noneOf("?")), "question"),
+  char("?"),
+]);
+
+const parser = seq<any, "name" | "question">([
+  helloParser,
+  space,
+  questionParser,
+]);
+
+const result = parser("hello adit! how are you?");
+console.log(result); */
+
+/* 
+if (result.success) {
+  console.log(result.captures?.name);
+}  */
+
+const input = `terraform {
+    required_providers {
+      aws = {
+        source = "hashicorp"
+      }
+    }
+  }`;
+
+const line = seq<any, string>(
+  [
+    many(space),
+    capture(word, "key"),
+    many(space),
+    char("="),
+    many(space),
+    capture(quotedString, "value"),
+  ],
+  "line"
+);
+
+let block: any = char("{");
+block = shapeCaptures(
+  seq<any, string>(
+    [
+      manyWithJoin(space),
+      capture(
+        or(
+          [str("terraform"), str("required_providers"), str("aws")],
+          "blockName"
+        ),
+        "blockName"
+      ),
+      space,
+      optional(str("= ")),
+      char("{"),
+      manyWithJoin(space),
+      // this works
+      or([line, (x) => block(x)], "line or block"),
+      // but this doesnt
+      // many(or([line, (x) => block(x)], "line or block")),
+      // nor this
+      // many1(or([line, (x) => block(x)], "line or block")),
+      manyWithJoin(space),
+      char("}"),
+    ],
+    "block"
+  ),
+  ({ blockName }) => ({ blockName }),
+  "block"
+);
+
+const result2 = block(input);
+console.log(result2);
+if (result2.success) {
+  console.log(JSON.stringify(result2.captures, null, 2));
+}

package/lib/combinators.ts

@@ -0,0 +1,224 @@
+import { trace } from "./trace";
+import { Parser, ParserSuccess } from "./types";
+import { escape, merge, mergeCaptures } from "./utils";
+
+export function many<T>(parser: Parser<T>): Parser<T[]> {
+  return trace("many", (input: string) => {
+    let match: T[] = [];
+    let rest = input;
+    while (true) {
+      let result = parser(rest);
+      if (!result.success) {
+        return { success: true, match, rest };
+      }
+      match.push(result.match);
+      rest = result.rest;
+    }
+  });
+}
+
+export function many1<T>(parser: Parser<T>): Parser<T[]> {
+  return trace(`many1`, (input: string) => {
+    let result = many(parser)(input);
+    // this logic doesn't work with optional and not
+    if (result.rest !== input) {
+      return result;
+    }
+    return {
+      success: false,
+      rest: input,
+      message: "expected at least one match",
+    };
+  });
+}
+
+export function manyWithJoin(parser: Parser<string>): Parser<string> {
+  return transform<string[], string>(many(parser), (x) => x.join(""));
+}
+
+export function many1WithJoin(parser: Parser<string>): Parser<string> {
+  return transform<string[], string>(many1(parser), (x) => x.join(""));
+}
+
+export function or<T>(parsers: Parser<T>[], name: string = ""): Parser<T> {
+  return trace(`or(${name})`, (input: string) => {
+    for (let parser of parsers) {
+      let result = parser(input);
+      if (result.success) {
+        return result;
+      }
+    }
+    return {
+      success: false,
+      rest: input,
+      message: "all parsers failed",
+    };
+  });
+}
+
+export function optional<T>(parser: Parser<T>): Parser<T | null> {
+  return trace<T | null>("optional", (input: string) => {
+    let result = parser(input);
+    if (result.success) {
+      return result;
+    }
+    return { success: true, match: null, rest: input };
+  });
+}
+
+export function not(parser: Parser<any>): Parser<null> {
+  return trace("not", (input: string) => {
+    let result = parser(input);
+    if (result.success) {
+      return {
+        success: false,
+        rest: input,
+        message: "unexpected match",
+      };
+    }
+    return { success: true, match: null, rest: input };
+  });
+}
+
+export function between<O, C, P>(
+  open: Parser<O>,
+  close: Parser<C>,
+  parser: Parser<P>
+): Parser<P> {
+  return (input: string) => {
+    const result1 = open(input);
+    if (!result1.success) {
+      return result1;
+    }
+    const parserResult = parser(result1.rest);
+    if (!parserResult.success) {
+      return parserResult;
+    }
+    const result2 = close(parserResult.rest);
+    if (!result2.success) {
+      return result2;
+    }
+    return { success: true, match: parserResult.match, rest: result2.rest };
+  };
+}
+
+export function sepBy<S, P>(
+  separator: Parser<S>,
+  parser: Parser<P>
+): Parser<P[]> {
+  return (input: string) => {
+    let match: P[] = [];
+    let rest = input;
+    while (true) {
+      const result = parser(rest);
+      if (!result.success) {
+        return { success: true, match, rest };
+      }
+      match.push(result.match);
+      rest = result.rest;
+
+      const sepResult = separator(rest);
+      if (!sepResult.success) {
+        return { success: true, match, rest };
+      }
+      rest = sepResult.rest;
+    }
+  };
+}
+
+export function seq<M, C extends string>(
+  parsers: Parser<M>[],
+  name: string = ""
+): Parser<M[], C> {
+  return trace(`seq(${name})`, (input: string) => {
+    let match: M[] = [];
+    let rest = input;
+    // @ts-ignore
+    let captures: Record<U, any> = {};
+    for (let parser of parsers) {
+      let result = parser(rest);
+      if (!result.success) {
+        return result;
+      }
+      match.push(result.match);
+      rest = result.rest;
+      if (result.captures) {
+        captures = mergeCaptures(captures, result.captures);
+      }
+    }
+    return { success: true, match, rest, captures };
+  });
+}
+
+export function capture<M, C extends string>(
+  parser: Parser<M>,
+  name: string
+): Parser<M, C> {
+  return trace(`captures(${escape(name)})`, (input: string) => {
+    let result = parser(input);
+    if (result.success) {
+      const captures: Record<string, any> = {
+        [name]: result.match,
+      };
+      return {
+        ...result,
+        captures: mergeCaptures(result.captures || {}, captures),
+      };
+    }
+    return result;
+  });
+}
+
+export function captureCaptures<M, C extends string>(
+  parser: Parser<M>,
+  name: string
+): Parser<M, C> {
+  return trace(`captures(${escape(name)})`, (input: string) => {
+    let result = parser(input);
+    if (result.success) {
+      const captures: Record<string, any> = {
+        [name]: result.captures,
+      };
+      return {
+        ...result,
+        captures: mergeCaptures(result.captures || {}, captures),
+      };
+    }
+    return result;
+  });
+}
+
+export function shapeCaptures<M, C extends string>(
+  parser: Parser<M>,
+  func: (captures: Record<string, any>) => Record<string, any>,
+  name: string
+): Parser<M, C> {
+  return trace(`captures(${escape(name)})`, (input: string) => {
+    let result = parser(input);
+    if (result.success) {
+      const captures: Record<string, any> = result.captures || {};
+
+      return {
+        ...result,
+        captures: func(captures),
+      };
+    }
+    return result;
+  });
+}
+
+export function transform<T, X>(
+  parser: Parser<T>,
+  transformerFunc: (x: T) => X
+): Parser<X> {
+  return trace(`transform(${transformerFunc})`, (input: string) => {
+    let result = parser(input);
+    if (result.success) {
+      return {
+        ...result,
+        match: transformerFunc(result.match),
+      };
+    }
+    return result;
+  });
+}

package/lib/index.ts

@@ -0,0 +1,3 @@
+export * from "./parsers";
+export * from "./combinators";
+export * from "./trace";