tarsec 0.0.1 → 0.0.2

package/lib/combinators.ts

@@ -1,224 +0,0 @@
-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/parsers.test.ts

@@ -1,300 +0,0 @@
-import { describe, expect, it, test } from "vitest";
-import {
-  alphanum,
-  digit,
-  letter,
-  noneOf,
-  num,
-  oneOf,
-  space,
-  spaces,
-  str,
-  word,
-  char,
-} from "./parsers";
-import { success, failure } from "../vitest.globals.js";
-import {
-  capture,
-  many,
-  many1,
-  many1WithJoin,
-  not,
-  optional,
-  or,
-  seq,
-} from "./combinators";
-test.skip("hello", () => {
-  describe("Parser Tests", () => {
-    describe("optional parser", () => {
-      const parser = optional(char("a"));
-
-      it("should parse the character if it exists", () => {
-        const result = parser("a");
-        expect(result).toEqual(success({ rest: "", match: "a" }));
-      });
-
-      it("should return an empty string if the character is missing", () => {
-        const result = parser("b");
-        expect(result).toEqual(success({ rest: "b", match: "" }));
-      });
-
-      it("should not consume any input if it fails", () => {
-        // @ts-ignore
-        const parser2 = optional(seq(many1WithJoin(letter), char("!")));
-        const result1 = parser2("hello!");
-        expect(result1).toEqual(
-          success({ rest: "", match: "hello!", captures: {} })
-        );
-
-        const result2 = parser2("hello");
-        expect(result2).toEqual(success({ rest: "hello", match: "" }));
-      });
-    });
-
-    describe("not parser", () => {
-      const parser = not(char("a"));
-
-      it("should fail if the character is present", () => {
-        const result = parser("a");
-        expect(result).toEqual(
-          failure({ rest: "a", message: "unexpected match" })
-        );
-      });
-
-      it("should return an empty string if the character is missing", () => {
-        const result = parser("b");
-        expect(result).toEqual(success({ rest: "b", match: "" }));
-      });
-    });
-
-    describe("space parser", () => {
-      it("should parse a space character", () => {
-        const result = space(" ");
-        expect(result).toEqual(success({ rest: "", match: " " }));
-      });
-
-      it("should fail if the character is not a space", () => {
-        const result = space("a");
-        expect(result).toEqual(
-          failure({ rest: "a", message: "expected  , got a" })
-        );
-      });
-    });
-
-    describe("spaces parser", () => {
-      it("should parse multiple space characters", () => {
-        const result = spaces("  ");
-        expect(result).toEqual(success({ rest: "", match: "  " }));
-      });
-
-      it("should fail if no space characters found", () => {
-        const result = spaces("abc");
-        expect(result).toEqual(
-          failure({ rest: "abc", message: "expected at least one match" })
-        );
-      });
-    });
-
-    describe("digit parser", () => {
-      it("should parse a single digit", () => {
-        const result = digit("1");
-        expect(result).toEqual(success({ rest: "", match: "1" }));
-      });
-
-      it("should fail if the character is not a digit", () => {
-        const result = digit("a");
-        expect(result).toEqual(
-          failure({ rest: "a", message: "expected one of 0123456789" })
-        );
-      });
-    });
-
-    describe("letter parser", () => {
-      it("should parse a single letter", () => {
-        const result = letter("a");
-        expect(result).toEqual(success({ rest: "", match: "a" }));
-      });
-
-      it("should fail if the character is not a letter", () => {
-        const result = letter("1");
-        expect(result).toEqual(
-          failure({
-            rest: "1",
-            message: "expected one of abcdefghijklmnopqrstuvwxyz",
-          })
-        );
-      });
-    });
-
-    describe("alphanum parser", () => {
-      it("should parse a single alphanumeric character", () => {
-        const result = alphanum("1");
-        expect(result).toEqual(success({ rest: "", match: "1" }));
-      });
-
-      it("should fail if the character is not alphanumeric", () => {
-        const result = alphanum("_");
-        expect(result).toEqual(
-          failure({
-            rest: "_",
-            message: "expected one of abcdefghijklmnopqrstuvwxyz0123456789",
-          })
-        );
-      });
-    });
-
-    describe("word parser", () => {
-      const parser = word;
-
-      it("should parse a single word", () => {
-        const result = parser("hello");
-        expect(result).toEqual(success({ rest: "", match: "hello" }));
-      });
-
-      it("should fail if no word characters found", () => {
-        const result = parser("123");
-        expect(result).toEqual(
-          failure({ rest: "123", message: "expected at least one match" })
-        );
-      });
-    });
-
-    describe("number parser", () => {
-      const parser = num;
-
-      it("should parse a single number", () => {
-        const result = parser("123");
-        expect(result).toEqual(success({ rest: "", match: "123" }));
-      });
-
-      it("should fail if no number characters found", () => {
-        const result = parser("abc");
-        expect(result).toEqual(
-          failure({ rest: "abc", message: "expected at least one match" })
-        );
-      });
-    });
-  });
-
-  describe("seq parser", () => {
-    const parser = seq([char("a"), char("b")]);
-
-    it("should parse both characters in sequence", () => {
-      const result = parser("ab");
-      expect(result).toEqual(success({ rest: "", match: "ab", captures: {} }));
-    });
-
-    it("should fail if any of the parsers fail", () => {
-      const result = parser("ac");
-      expect(result).toEqual(
-        failure({ rest: "c", message: "expected b, got c" })
-      );
-    });
-  });
-
-  describe("seq parser - hello world", () => {
-    it("multiple char parsers", () => {
-      const parser = seq([
-        char("h"),
-        char("e"),
-        char("l"),
-        char("l"),
-        char("o"),
-      ]);
-      const result = parser("hello world");
-      expect(result).toEqual(
-        success({ match: "hello", rest: " world", captures: {} })
-      );
-    });
-
-    it("multiple str parsers", () => {
-      const parser = seq([str("hello"), space, str("world")]);
-      const result = parser("hello world");
-      expect(result).toEqual(
-        success({ match: "hello world", rest: "", captures: {} })
-      );
-    });
-
-    it("multiple str parsers + capture", () => {
-      const parser = seq([str("hello"), space, capture(str("world"), "name")]);
-      const result = parser("hello world");
-      expect(result).toEqual(
-        success({ match: "hello world", rest: "", captures: { name: "world" } })
-      );
-    });
-  });
-
-  /* test("quote parser - single quote", () => {
-  const input = "'";
-  const result = quote(input);
-  expect(result).toEqual(success({ rest: "", match: "'", captures: {} }));
-});
-
-test("quote parser - double quote", () => {
-  const input = '"';
-  const result = quote(input);
-  expect(result).toEqual(success({ rest: "", match: '"', captures: {} }));
-});
-
-test("quote parser - invalid quote", () => {
-  const input = "`";
-  const result = quote(input);
-  expect(result).toEqual(
-    failure({ rest: "`", message: "unexpected end of input" })
-  );
-});
-
-// Test for anyChar parser
-test("anyChar parser - non-empty input", () => {
-  const input = "abc";
-  const result = anyChar(input);
-  expect(result).toEqual(success({ rest: "bc", match: "a", captures: {} }));
-});
-
-test("anyChar parser - empty input", () => {
-  const input = "";
-  const result = anyChar(input);
-  expect(result).toEqual(
-    failure({ rest: "", message: "unexpected end of input" })
-  );
-});
-
-// Test for between parser
-test("between parser - valid input", () => {
-  const open = quote;
-  const close = quote;
-  const parser = anyChar;
-  const input = "'abc'";
-  const result = between(open, close, parser)(input);
-  expect(result).toEqual(success({ rest: "", match: "a", captures: {} }));
-});
-
-test("between parser - invalid input", () => {
-  const open = quote;
-  const close = quote;
-  const parser = anyChar;
-  const input = "\"abc'";
-  const result = between(open, close, parser)(input);
-  expect(result).toEqual(
-    failure({ rest: "abc'", message: "unexpected end of input" })
-  );
-});
-
-// Test for sepBy parser
-test("sepBy parser - valid input", () => {
-  const separator = anyChar;
-  const parser = anyChar;
-  const input = "a,b,c";
-  const result = sepBy(separator, parser)(input);
-  expect(result).toEqual(success({ rest: "", match: "abc", captures: {} }));
-});
-
-test("sepBy parser - invalid input", () => {
-  const separator = quote;
-  const parser = anyChar;
-  const input = '"a"bc';
-  const result = sepBy(separator, parser)(input);
-  expect(result).toEqual(success({ rest: "bc", match: "a", captures: {} }));
-});
- */
-});

package/lib/parsers.ts

@@ -1,108 +0,0 @@
-import { many1, many1WithJoin, seq, transform } from "./combinators";
-import { trace } from "./trace";
-import { Parser, ParserResult } from "./types";
-import { escape } from "./utils";
-export function char(c: string): Parser<string> {
-  return trace(`char(${escape(c)})`, (input: string) => {
-    if (input.length === 0) {
-      return {
-        success: false,
-        rest: input,
-        message: "unexpected end of input",
-      };
-    }
-    if (input[0] === c) {
-      return { success: true, match: c, rest: input.slice(1) };
-    }
-    return {
-      success: false,
-      rest: input,
-      message: `expected ${c}, got ${input[0]}`,
-    };
-  });
-}
-
-export function str(s: string): Parser<string> {
-  return trace(`str(${escape(s)})`, (input: string) => {
-    if (input.substring(0, s.length) === s) {
-      return { success: true, match: s, rest: input.slice(s.length) };
-    }
-    return {
-      success: false,
-      rest: input,
-      message: `expected ${s}, got ${input.substring(0, s.length)}`,
-    };
-  });
-}
-
-export function oneOf(chars: string): Parser<string> {
-  return trace(`oneOf(${escape(chars)})`, (input: string) => {
-    if (input.length === 0) {
-      return {
-        success: false,
-        rest: input,
-        message: "unexpected end of input",
-      };
-    }
-    const c = input[0];
-    if (chars.includes(c)) {
-      return char(c)(input);
-    }
-    return {
-      success: false,
-      rest: input,
-      message: `expected one of ${escape(chars)}, got ${c}`,
-    };
-  });
-}
-
-export function noneOf(chars: string): Parser<string> {
-  return trace(`noneOf(${escape(chars)})`, (input: string) => {
-    if (input.length === 0) {
-      return {
-        success: false,
-        rest: input,
-        message: "unexpected end of input",
-      };
-    }
-    if (chars.includes(input[0])) {
-      return {
-        success: false,
-        rest: input,
-        message: `expected none of ${chars}`,
-      };
-    }
-    return char(input[0])(input);
-  });
-}
-
-export function anyChar(input: string): Parser<string> {
-  return trace("anyChar", (input: string) => {
-    if (input.length === 0) {
-      return {
-        success: false,
-        rest: input,
-        message: "unexpected end of input",
-      };
-    }
-    return { success: true, match: input[0], rest: input.slice(1) };
-  });
-}
-
-export const space: Parser<string> = oneOf(" \t\n\r");
-export const spaces: Parser<string> = many1WithJoin(space);
-export const digit: Parser<string> = oneOf("0123456789");
-export const letter: Parser<string> = oneOf("abcdefghijklmnopqrstuvwxyz");
-export const alphanum: Parser<string> = oneOf(
-  "abcdefghijklmnopqrstuvwxyz0123456789"
-);
-export const word: Parser<string> = many1WithJoin(letter);
-export const num: Parser<string> = many1WithJoin(digit);
-export const quote: Parser<string> = oneOf(`'"`);
-export const tab: Parser<string> = char("\t");
-export const newline: Parser<string> = char("\n");
-
-export const quotedString = transform(
-  seq<any, string>([quote, word, quote], "quotedString"),
-  (x) => x.join("")
-);

package/lib/trace.ts

@@ -1,40 +0,0 @@
-import { ParserResult, Parser } from "./types";
-import { escape } from "./utils";
-const STEP = 2;
-
-export function resultToString<T>(
-  name: string,
-  result: ParserResult<T, string>
-): string {
-  if (result.success) {
-    return `✅ ${name} -- match: ${escape(result.match)}, rest: ${escape(
-      result.rest
-    )}`;
-  }
-  return `❌ ${name} -- message: ${escape(result.message)}, rest: ${escape(
-    result.rest
-  )}`;
-}
-
-let level = 0;
-
-export function trace<T>(name: string, parser: Parser<T>): Parser<T> {
-  return (input: string) => {
-    if (process.env.DEBUG) {
-      console.log(" ".repeat(level) + `🔍 ${name} -- input: ${escape(input)}`);
-    }
-    level += STEP;
-    const result = parser(input);
-    level -= STEP;
-    if (process.env.DEBUG) {
-      console.log(" ".repeat(level) + resultToString(name, result));
-      if (result.success && result.captures) {
-        console.log(
-          " ".repeat(level) +
-            `⭐ ${name} -- captures: ${JSON.stringify(result.captures)}`
-        );
-      }
-    }
-    return result;
-  };
-}

package/lib/types.ts

@@ -1,24 +0,0 @@
-export type Object = Record<string, string>;
-export type ParserSuccess<M, C extends string> = {
-  success: true;
-  match: M;
-  captures?: Record<C, any>;
-  rest: string;
-};
-
-export type ParserFailure = {
-  success: false;
-  rest: string;
-  message: string;
-};
-
-export type ParserOptions = {
-  capture: string;
-};
-
-export type ParserResult<M, C extends string> =
-  | ParserSuccess<M, C>
-  | ParserFailure;
-export type Parser<M, C extends string = string> = (
-  input: string
-) => ParserResult<M, C>;